1. Bucle unidireccional: he organizado las funciones de varias funciones aprendidas aquí. Espero progresar junto con todos. ¡Corríjame si hay algún error!
El siguiente es un resumen de estas funciones, que es también la esencia de este artículo, la siguiente lista doblemente enlazada completa las tres tareas dejadas por el docente.
Status init(Node* p);//Asignar un valor inicial requiere modificar el puntero y operar con la dirección del puntero**p
Status insert_head(Node p,Elementype value);//La función de inserción primero se aplica a una dirección y devuelve el resultado y luego procesa los punteros (los puntos p->siguientes antes y después)
Estado insert_tail(Nodo p,Elementype valor);//La dirección de la aplicación es la misma que la anterior
Estado insert_index(Nodo p,int index,Elementype value);// Primero determine la legalidad de la posición de inserción, solicite el espacio como se indica arriba, repita los tiempos del índice del puntero, procese el puntero
void print(Node p);// Utilice el bucle for para completar la salida de la lista vinculada
int length (Nodo p);// La función función es similar a la anterior, cambie la salida a una personalizada Solo cuente las variables, preste atención al valor de retorno Estado delete_index
(Nodo p, int index);// Juzgue el razonabilidad de la posición de eliminación, recorra la posición y procese el puntero
Estado eliminar_valor (Nodo p, valor de tipo de elemento); // Recorra la tabla de secuencia y encuentre el valor correspondiente, llame a la función anterior (cuento), preste atención al procesamiento el valor correspondiente continuo
Status update_index(Node p, int index, Elementype value);// Juzga la racionalidad de la posición de reemplazo, recorre la posición correspondiente y asigna directamente el valor Status update_value(Node p, Elementtype
old_name, Elementtype new_name) ;//Recorre la tabla de secuencia, encuentra el valor correspondiente y asigna un nuevo valor
Status query_index(Node p, int index);// Juzga la racionalidad de la posición, recorre la posición especificada para imprimir el valor
Status query_value(Node p,Elementype value);// Mientras recorre la tabla de secuencia y cuenta con i, juzgue el valor correspondiente y emita i
/*************************************************** ****
> Nombre del archivo: 4xunhuan.c
> Autor: Li Shang
> 日期: 2018-08-02 15:38
************************* *******************************/#incluir <stdio.h>
#incluir <stdlib.h>#definir F 0
#definir T 1typedef int Estado;
typedef int Tipo de elemento;
typedef estructura nodo* Nodo;nodo de estructura
{ valor de tipo de elemento; nodo de estructura* siguiente; };Status init(Node* p);// La asignación de un valor inicial requiere modificar el puntero, **p
Status insert_head(Node p,Elementype value);//La función de inserción primero solicita una dirección, devuelve el resultado y luego procesa el puntero
Estado insert_tail (Nodo p,Elementype valor);//La dirección de la aplicación es la misma que la anterior.
Estado insert_index(Nodo p,int index,Elementype valor);//Primero determine la legalidad de la posición de inserción, solicite espacio , recorra el puntero en la posición y procese el puntero void
print(Node p);
int length(Node p);
Status delete_index(Node p, int index);// Juzgue la razonabilidad de la posición de eliminación, recorra la posición y procesa el puntero
Estado eliminar_valor (Nodo p, Valor de tipo de elemento); // Recorre la tabla de secuencia, encuentra el valor correspondiente, llama a la función anterior (cuento), presta atención al procesamiento del valor correspondiente continuo Estado update_index (Nodo p
, int index, Elementype value); // Juzga la racionalidad de la posición de reemplazo, recorre la posición correspondiente y asigna directamente el
estado update_value (Node p,Elementtype old_name,Elementtype new_name);//Recorre la tabla de secuencia, encuentra el valor correspondiente y asigne un nuevo valor
Estado query_index(Node p,int index);//Determina la racionalidad de la posición, recorre la posición especificada para imprimir el valor
Estado query_value(Node p,Elementype value);//mientras recorre la tabla de secuencia y cuenta con i, determina el valor correspondiente y genera iint principal()
{ int i; Cabeza de nodo; inicio(&cabeza); for (i = 0; i < 10; i++) { insert_head(cabeza,i + 1); } imprimir(cabeza); for (i = 0; i < 10; i++) { insert_tail(cabeza,i + 1); } imprimir(cabeza);
update_index(cabeza,2,6);
imprimir(cabeza);
insert_index(cabeza,2,8);
imprimir(cabeza);eliminar_index(cabeza,2);
imprimir(cabeza);eliminar_valor(cabeza,6);
imprimir(cabeza);
update_value(cabeza,8,66);
imprimir(cabeza);valor_consulta(cabeza,3);
query_index(cabeza,6);
devolver 0;
}Estado init(Nodo* p)
{ Nodo nuevonodo = (Nodo)malloc(sizeof(struct node));//动态空间 if(NULL == nuevonodo) { return F; } nuevonodo->siguiente = nuevonodo; *p = nuevonodo; devolver T; }
Estado insert_head(Nodo p,Valor de tipo de elemento)
{ Nodo nuevonodo = (Nodo)malloc(tamañode(estructura nodo)); if(NULL == nuevonodo) { return F; } nuevonodo -> valor = valor; nuevonodo -> siguiente = p -> siguiente; p -> siguiente = nuevonodo; devolver T; }
Estado insert_tail (Nodo p, valor de tipo de elemento)
{ Cabeza de nodo = p; Nodo nuevonodo = (Nodo)malloc(tamañode(estructura nodo)); if(NULL == nuevonodo) { return F; } while(cabeza != p->siguiente) { p = p->siguiente; } nuevonodo->valor = valor; nuevonodo->siguiente = p->siguiente; p->siguiente = nuevonodo; devolver T; }
Estado insert_index(Nodo p,índice int,valor de tipo de elemento)
{ int i; if(índice < 0 || índice > longitud(p) - 1) { printf("el índice es error\n"); devolver F; } Nodo nuevonodo = (Nodo)malloc(tamañode(estructura nodo)); if(NULL == nuevonodo) { return F; } for(i = 0;i < índice;i++) { p = p->siguiente; } nuevonodo->valor = valor; nuevonodo->siguiente = p->siguiente; p->siguiente = nuevonodo; devolver T; }
void print(Nodo p)
{ Cabeza de nodo = p; while(cabeza!= p->siguiente) { printf("%d ",p->siguiente->valor); p = p->siguiente; } printf("\n"); }
int longitud(Nodo p)
{ Cabeza de nodo = p; longitud int = 0; while(cabeza!= p->siguiente) { len++; p = p->siguiente; } devolver longitud; }
Estado eliminar_índice(Nodo p,int índice)
{ if(índice < 0 || índice > longitud(p) - 1) { printf("el índice es error\n"); devolver F; } int yo; for (i = 0; i < índice; i++) { p = p->siguiente; } Temperatura del nodo = p->siguiente->siguiente; gratis(p->siguiente); p->siguiente = temporal; devolver T;
}
Estado eliminar_valor (Nodo p, valor de tipo de elemento)
{ int i = 0; Cabeza de nodo = p; printf("valor = %d\n",valor); while(cabeza!= p->siguiente) { if (valor == p->siguiente->valor) { eliminar_index(cabeza,i); printf("la dirección de eliminación es %d\n",i); } más { i++; p = p->siguiente; } } devolver T; }
Estado update_index(Nodo p,índice int,valor de tipo de elemento)
{ if(índice < 0 || índice > longitud(p) - 1) { printf("el índice es error\n"); devolver F; }
ent i;
for (i = 0; i < índice; i++)
{ p = p->siguiente; } p->siguiente->valor = valor; devolver T; }Estado update_value(Node p,Elementtype old_name,Elementtype new_name)
{ Node head = p; while(head != p->next) { if(p->next->value == old_name)//Mal de nuevo, asignación e igual para notar la diferencia { p->siguiente->valor = nuevo_nombre; } p = p->siguiente; } devolver T; }
Estado query_index(Node p,int index)
{ if(index < 0 || index > length(p) - 1)//Juzga si la posición de inserción se ingresó correctamente { printf("index is error\n"); return F ; } int i; for(i = 0;i < index;i++) { p = p->siguiente; } printf("el índice %d es %d\n",i,p->siguiente->valor ); }
Estado valor_consulta (Nodo p, valor de tipo de elemento)
{ Cabeza de nodo = p; int yo = 0; bandera int = 0; printf("el valor deseado es %d\n",valor); while(cabeza!= p->siguiente) { if(valor == p->siguiente->valor) { printf("%d ",i); bandera++; } yo++; p = p->siguiente; } if(bandera == 0) { printf("no encontrado\n"); } printf("\n"); devolver T; }
2. Lista doblemente enlazada, algunos códigos de función se modificaron y depuraron con éxito en función de la lista enlazada unidireccional.
/*************************************************** ***** ****
> Nombre del archivo: 5shuangxiang.c
> Autor: Li Shang
> Fecha: 2018-08-03 15:56
****************** ***** *******************************/#incluir <stdio.h>
#incluir <stdlib.h>#definir T 1
#definir F 0typedef int Tipo de elemento;
typedef int Estado;estructura Nodo
{ estructura Nodo* anterior; Valor de tipo de elemento; estructura Nodo* siguiente; };typedef estructura Nodo* nodo;
Estado inicial (nodo* p);
Estado insert_head (nodo p, valor de tipo de elemento);
impresión vacíaN (nodo p);
void printP(nodo p);
longitud int (nodo p);
Estado insert_tail (nodo p, valor de tipo de elemento);
Estado insert_index (nodo p, índice int, valor de tipo de elemento);
Estado eliminar_índice (nodo p, índice int);
Estado eliminar_valor (nodo p, valor de tipo de elemento);int main()
{ cabeza de nodo; inicio(&cabeza); ent i; for (i = 0; i < 10; i++) { insert_head(cabeza,i+1); } imprimirN(cabeza); imprimirP(cabeza);
for (i = 0; i < 10; i++)
{ insert_tail(cabeza,i+1); } imprimirN(cabeza); imprimirP(cabeza);insert_index(cabeza,5,99);
imprimirN(cabeza);eliminar_index(cabeza,6);
imprimirN(cabeza);eliminar_valor(cabeza,6);
imprimirN(cabeza);
devolver 0;
}Estado init(nodo* p)
{ nodo nuevonodo = (nodo)malloc(sizeof(struct Node)); if(NULL == nuevonodo) { return F; } nuevonodo->siguiente = nuevonodo; nuevonodo->anterior = nuevonodo; *p = nuevonodo; }
Estado insert_head(nodo p, valor de tipo de elemento)
{ nodo nuevonodo = (nodo)malloc(tamañode(estructura Nodo)); if(NULL == nuevonodo) { return F; } nuevonodo->valor = valor; nuevonodo->siguiente = p->siguiente; p->siguiente = nuevonodo; nuevonodo->anterior = p; nuevonodo->siguiente->anterior = nuevonodo; }
Estado insert_tail(nodo p, valor de tipo de elemento)
{ nodo nuevonodo = (nodo)malloc(tamañode(estructura Nodo)); if(NULL == nuevonodo) { return F; } nuevonodo->valor = valor; /*cabeza de nodo = p; while(cabeza!= p->siguiente) { p = p->siguiente; } nuevonodo->siguiente = cabeza; p->siguiente = nuevonodo; cabeza->prior = nuevonodo; nuevonodo->anterior = p;*/ nuevonodo->siguiente = p; p->anterior->siguiente = nuevonodo; nuevonodo->prior = p->prior; p->prior = nuevonodo; }
void printN(nodo p)
{ cabeza de nodo = p; while(cabeza!= p->siguiente) { printf("%d ",p->siguiente->valor); p = p->siguiente; } printf("\n"); }
void printP(nodo p)
{ cabeza de nodo = p; while(cabeza!= p->prior) { printf("%d ",p->prior->valor); p = p->antes; } printf("\n"); }
int longitud(nodo p)
{ int i = 0; cabeza de nodo = p; while(cabeza!= p->siguiente) { i++; p = p->siguiente; } devolver yo; }
Estado insert_index(nodo p,int índice,valor de tipo de elemento)
{ if (índice < 0 || índice > longitud(p) - 1) { printf("el índice es error\n"); devolver F; } nodo nuevonodo = (nodo)malloc(sizeof(struct Node)); if (NULL == nuevonodo) { return F; } int yo; for(i = 0;i < índice;i++) { p = p->siguiente; } nuevonodo->valor = valor; nuevonodo->siguiente = p->siguiente; p->siguiente = nuevonodo; nuevonodo->anterior = p; nuevonodo->siguiente->anterior = nuevonodo; devolver T;
}
Estado eliminar_índice(nodo p,int índice)
{ if (índice < 0 || índice > longitud(p) - 1) { printf("el índice es error\n"); devolver F; } int yo; for(i = 0;i < índice;i++) { p = p->siguiente; } temperatura del nodo = p->siguiente->siguiente; gratis(p->siguiente); p->siguiente = temporal; temp->siguiente->anterior = p; devolver T; }
Estado eliminar_valor (nodo p, valor de tipo de elemento)
{ int i = 0; cabeza de nodo = p; while(cabeza!= p->siguiente) { if (valor == p->siguiente->valor) { eliminar_index(cabeza,i); } más { i++; p = p->siguiente; } } devolver T; }