Diccionario de lista enlazada de lenguaje c
#Contiene "stdio.h"
#Contiene "stdlib.h"
#Definir estado int
#Definir desbordamiento 0
#Definir verdadero 1
#Definir falso 0
#Definir OK 1
#Definir MAXSIZE 100
typedef int ElemType
lista de estructura typedef
{ elem tipo elem[MAXSIZE];
int longitud;
} ListaSq
void InitList(SqList amp; L){
l longitud = 0
}
/* Crear. lista de secuencia*/
void create list(SqList amp; l)
{
int I;
printf("Longitud de entrada ");
scanf("d", amp length); //Ingrese la longitud de la tabla
for(I = 1; I lt=L. length; i)
scanf("d ", ampl . elem[I-1]);//Elementos de entrada
}
//Recorrido de la tabla de secuencias
void printdata(ElemType e){
printf("4d ", e);
}
void Traverse(lista SQL L, void( * visita)(tipo de elemento e))
{ int I;
printf("Los elementos de la lista son:\n ");
for( I = 1;ilt=L.length;i){
if(I 10 == 0)printf("\n"); //Mostrar 10 elementos por línea.
Access (l . elem[I-1]); //Salida de los elementos en la tabla
}
printf("\n");
}
//Inserte el elemento E en la lista de secuencia ordenada L para que la secuencia aún esté ordenada.
Inserción vacía (SqList ampl, ElemType e)
{int i, j;
if (L.length==MAXSIZE)exit(overflow); //La tabla está llena y no se puede insertar.
for(I = 1; i lt=longitud y longitud. ampl . elem[I-1] lt;= e;i); //Mirar hacia atrás
for( j = l . longitud; j gt = I; j -)
l . elem[j]= l . elem[I-1] = e; //Insertar e
l . >
//Crea una lista de secuencia ordenada incrementalmente.
lista de creación nula _ Sorted(SqList amp; l)
{int i, num
elem type e
l. length = 0;
printf("Crea una lista ordenada, ingresa la longitud de la lista\n");
scanf("d", ampnum);
printf("Datos de entrada d números\n ",num);
for(I = 1;Ilt=numi){
scanf("d",ampe) ;
Insertar (L, e);
}
}
/*Fusionar dos listas ordenadas*/
void MergeList(SqList La, SqList Lb, SqList ampLc)
{int *pa, *pb, * pc
if(la . longitud lb . longitud gt; MAXSIZE ) salir (desbordamiento);
Otro
{ pa = La.elempb = Lb.elempc = Lc.elem
Y (pa lt longitud y longitud. amppb lt libra elemento libra longitud)
* pc = (* pa lt; = * pb)? * pa: * p b; /*Público * * *Fusión parcial*/
And (pa ltla. elem la. length)* pc = * pa;
/*R1 table El resto de la tabla se coloca después de R*/
while(Pb lt; lb . elem lb . length)* pc = * p b;
/*El resto de la R2 tabla Después de R*/
LC longitud = la longitud lb ;/*R longitud de la tabla*/
}
}
.//Determina si el elemento es simétrico. La simetría devuelve VERDADERO o FALSO.
Simetría de estado (SqList L)
{int low, high;
low = 0
high = l. 1;
mientras(bajo lt; alto)
if(l . elem[bajo]= = l . elem[alto]){ bajo ;}
else devuelve (FALSE); devuelve (verdadero);}
//La parte de la función principal de la lista de secuencia
//#Contiene " seqlist.h "< /p >
void main()
{ SqList L 1 de L2;
int select
elem tipo e;
do { printf(" \ n 1 insertar 2 fusionar ");
printf("\n3simétrico 0 salir\n ");
printf("Por favor seleccione (0-3) ) \n ");
scanf("d", amp select);
switch(select){
Caso 1:
InitList(L);
crear lista _ Sorted(L);
Atravesar (L, imprimir datos);
printf("\nInserción de entrada Elemento\n ");
scanf("d ", ampe);
Insertar (L, e);
Traverse (L, imprimir datos) ;
Romper;
Caso 2:
InitList(l 1);
crear lista _ Ordenada(l 1); /p>
Traverse(L1, imprimir datos);
InitList(L2);
crear lista _ Sorted(L2); L2, imprimir datos);
InitList(L);
Fusionar lista (L1, L2, L);
Traverse (L, imprimir datos);
Romper;
Caso 3:
InitList(L);
Crear lista(L);
Atravesar (L, imprimir datos);
if (Symmetric(L)) printf("¡Sí!\ n "); else printf(" No \ n ");
Roto;
Caso 0: Roto;
Valor predeterminado: printf("¡Error! ¡Intentar otra vez! \ n ");
}
} while(select);
}
/*Ejemplos de operaciones relacionadas con uno- listas enlazadas* /
/*Escriba definición y archivo de encabezado, el nombre del archivo es sllink.h*/
# include ltstdio.h gt
# include ltstdlib.h gt
typedef int ElemType//tipo real de elemento
estructura typedef LNode{
Datos del tipo de elemento;
struct LNode * next
}LNode, * LinkList // Definir nombres de tipos de nodos y punteros.
//Método de complemento para crear una lista vinculada desordenada
void CreateList(lista vinculada ampL){
Lista vinculada p;
tipo de elemento e ;
l =(LinkList)malloc(sizeof(LNode));
l- gt; next = NULL
Printf("Inserción de encabezado método para crear una lista enlazada que termina en 0\n ");
scanf("d ", ampe);
while(e){
p = (LinkList)malloc (tamaño de (LNode));
p->; datos = e
p->; siguiente = L- gt; >
l - gt; siguiente = p;
scanf("d ", amperio
}
}
void Insert_Sort(lista enlazada ampl, ElemType e){
Lista enlazada p, s;
s =(LinkList)malloc(sizeof(LNode));
s- gt; data = e;
p = L;
while(p -> next amp ampp-> next - gt; data lt = e)
p = p- gt /*buscar posición de inserción* /
s - gt; next = p- gt; next; /* Insertar declaración *p nodo, luego insertar *s nodo */
p->;
}
/*Crear una lista enlazada unidireccional ordenada incrementalmente*/
void Create_Sort(lista enlazada ampL){
tipo de elemento e;
l =(LinkList)malloc(sizeof(LNode));
l- gt; next = NULL
Printf("Construir un lista ordenada, ingrese cualquier dato entero hasta 0 termina\n ");
scanf("d", ampe);
while(e){
Insert_Sort(L, e);
scanf("d ", ampe);
}
}
/*Recorrido de lista enlazada unidireccional*/
Recorrido no válido (lista enlazada L){
Lista enlazada p;
Printf("Recorrer lista enlazada");
for(p = L- gt ; siguiente; p; p = p- gt; siguiente)
printf("5d", p- gt;data);
printf("\n");
}
/*Eliminar elemento e*/
Eliminación no válida (lista vinculada apl, ElemType e) {
Lista enlazada p, q ;
p = L;
q = L- gt;Siguiente;
Y (q amp ampq->;datos! =e){//Encuentra la posición eliminada del elemento.
p = q;
q = q- gt; siguiente
}
Si (! q) printf (" \ nno eliminado");/*elemento e*/
else { p- gt; siguiente = q- gt; siguiente; /*encontrado para eliminación*/
libre ( q) ;}
}
/*Reversión de lista enlazada unidireccional*/
Intercambio no válido (lista enlazada ampL){
Lista enlazada p, s;
p = L- gt; siguiente;
l- gt; siguiente = NULL
mientras(p){
s = p;
p = p- gt; siguiente;
s- gt; siguiente = L- gt; - gt; next = s;
}
}
/*Dos listas enlazadas unidireccionales ordenadas no decrecientes siguen siendo una secuencia no decreciente después fusionando* /
Lista enlazada La, lista enlazada Lb, lista enlazada ampLc){
Lista enlazada p, q, s, después;
p = La - gt; siguiente;
q=Lb->Siguiente;
Lc=Rear=La
Libre (libras);
Y (p amp ampQ){
if (p->data ltq->data){ s = p = p- gt }
else { s =; q; q = q- gt; }
detrás de gt; siguiente = s; /*Elemento más pequeño insertado en el pie de página*/
detrás de
}
if(p)rear-gt; next = p; else rear-gt = q; *Parte de la función principal, el nombre del archivo es sllink.c*/
//#Contiene " sllink.h "
void main(){
Vinculado list La, Lb, Lc;
elem type e;
int select
Do {
Printf(" 1Crear una lista desordenada y luego elimine el elemento especificado\n ");
Printf(" 2.
Cree una lista ordenada incremental y luego invierta\n ");
Printf("3)Cree dos listas ordenadas incrementales y combínelas en una tabla que aún crece\n");
Printf("0 para salir, ingrese una opción (0-3)\n");
scanf("d", amp select);
Switch(Select){
Caso 0:
Pausa;
Caso 1:
Crear Lista(La);
p >
Traverse (La);
Printf("Ingrese el elemento a eliminar\n");
scanf("d", ampe);
Eliminar (La, e);
Atravesar (La);
Romper;
Caso 2:
crear _ ordenar(La);
Traverse (La);
exch(La);
printf("Lista intercambiada\ n "
);Travesía (La);
Romper;
Caso 3:
crear _ Ordenar (La);
crear _ Ordenar(Lb); atravesar (lb);
MergeIncrease(La, Lb, Lc); atravesar (Lc); p>Valor predeterminado:
Printf("Error en la opción de entrada, ¡vuelva a ingresar!\n ");
}
} while(select);
}
No sé si este contenido puede ayudarte.