Estructura de datos: diseñe un algoritmo para descomponer una lista enlazada individualmente A con el nodo principal en dos listas enlazadas individualmente A y B con el nodo principal.
El programa es el siguiente:
#include lt;stdio.hgt;
#include lt;stdlib.hgt;
typedef nodo de estructura
{
datos de caracteres;
nodo de estructura *nextPtr;
}*LinkList, Lnode;
static void CreateList(LinkList *headPtr, LinkList *tailPtr, char ch);
static void Decompose(LinkList *headPtrA, LinkList *headPtrB, LinkList *tailPtrB);
static void VisitList (LinkList headPtr);
static void DestroyList(LinkList *headPtr, LinkList *tailPtr);
int main(void)
{
LinkList headPtrA = NULL, tailPtrA = NULL, headPtrB = NULL, tailPtrB = NULL;
char ch;
mientras (1)
{
p>
printf("Ingrese ch('@'-quit): ");
scanf(" c", amp; ch);
if (ch = = '@')
{
romper;
}
else
{
CreateList(amp; headPtrA, amp; tailPtrA, ch);
}
}
VisitList(headPtrA ); /* Imprimir antes de la descomposición Lista enlazada*/
if (headPtrA != NULL) /* Descomponer la lista enlazada si no está vacía*/
{
Decompose(amp; headPtrA , amp; headPtrB, amp; tailPtrB /* Descomponer la lista enlazada*/
}
else
{
printf ("headPtrA está vacío.\n");
}
VisitList(headPtrA /* Imprime la lista enlazada descompuesta*/
VisitList(headPtrB );
DestroyList(amp; headPtrA, amp; tailPtrA /* Destruye la lista enlazada*/
DestroyList(amp; headPtrB, amp). ; tailPtrB);
return 0;
}
CreateList vacío estático(LinkList *headPtr, LinkList *tailPtr, char ch)
{
ListaEnlaces newPtr;<
/p>
if ((newPtr = (LinkList)malloc(sizeof(Lnode))) == NULL)
{
salir(1);
}
newPtr -gt; datos = ch;
newPtr -gt; nextPtr = NULL;
if (*headPtr == NULL)
{
nuevoPtr -gt; nextPtr = *cabezaPtr;
*cabezaPtr = nuevoPtr
}
else
{
(*tailPtr) -gt; nextPtr = nuevoPtr;
}
*tailPtr = nuevoPtr;
}
descomposición estática vacía (LinkList *headPtrA, LinkList *headPtrB, LinkList *tailPtrB)
{
int count = 0; p>
LinkList cA, pA;
char ch;
cA = NULL;
for (pA = *headPtrA; pA != NULL; cA = pA, pA = pA -gt; nextPtr)
{
ch = pA -gt;
recuento;
if (cuenta 2 == 0)
{
CreateList(headPtrB, tailPtrB, ch);
cA -gt nextPtr = pA - gt; nextPtr;
}
}
}
VisitList vacío estático(LinkList headPtr)
{
mientras (headPtr != NULL)
{
printf("c -gt; ", headPtr -gt; datos);
headPtr = headPtr -gt; nextPtr;
}
printf("NULL\n"); void DestroyList (LinkList *headPtr, LinkList *tailPtr)
{
LinkList tempPtr;
mientras (*headPtr != NULL)
{
tempPtr = *headPtr;
*headPtr = (*headPtr) -gt; nextPtr;
libre(tempPtr);
}
*headPtr = NULL;
*tailPtr = NULL;
}
Lenguaje de consulta estructurado (Lenguaje de consulta estructurado) abreviatura SQL (pronunciada: /?es kju el/ "S-Q-L"), es un lenguaje de programación de propósito especial, una consulta de base de datos y un lenguaje de programación utilizado para almacenar
Obtenga datos y consulte, actualice y administre sistemas de bases de datos relacionales; también la extensión para archivos de script de bases de datos.
El lenguaje de consulta estructurado es un lenguaje de programación no procedimental de alto nivel que permite a los usuarios trabajar en estructuras de datos de alto nivel. No requiere que los usuarios especifiquen el método de almacenamiento de datos ni que comprendan el método de almacenamiento de datos específico. Por lo tanto, diferentes sistemas de bases de datos con estructuras subyacentes completamente diferentes pueden utilizar el mismo lenguaje de consulta estructurado como interfaz para la entrada y gestión de datos. . Las declaraciones del lenguaje de consulta estructurado se pueden anidar, lo que lo hace extremadamente flexible y potente.
En octubre de 1986, el Instituto Nacional Estadounidense de Estándares estandarizó SQL y lo utilizó como lenguaje estándar para sistemas de gestión de bases de datos relacionales (ANSI X3. 135-1986). En 1987, recibió el apoyo de la Organización Internacional de Estándares. . convertirse en un estándar internacional. Sin embargo, varios sistemas de bases de datos populares han realizado algunas modificaciones y ampliaciones a las especificaciones SQL en su práctica. Por lo tanto, de hecho, SQL entre diferentes sistemas de bases de datos no puede ser completamente intercambiable.