Hay mucho que aprender hoy. La llamada mutua de funciones y el uso inteligente de punteros son puntos difíciles de aprender. La siguiente es una autoevaluación e inspección basada en código. Espero que podamos aprender unos de otros y progresar juntos”. La lógica de las tablas de secuencia no es difícil de aprender, lo que sí es difícil es pensar con cuidado y mantener las ideas claras. Es necesario considerar todas las posibilidades y no se puede ignorar la conversión o definición de cada tipo de datos.
1.Definición de tabla lineal
Defina una secuencia finita de n elementos de datos, denotada como (a1, a2,…, an) ai es el elemento de datos en la tabla, n es la longitud de la tabla
2. Características de las mesas lineales
Cada elemento, excepto el primero, tiene uno y sólo un predecesor inmediato.
Cada elemento excepto el último elemento tiene un y sólo un sucesor directo.
3. Definición y características de lista de secuencias.
Definición: Almacene los elementos en una lista lineal uno tras otro en un espacio de almacenamiento continuo.
Se pueden utilizar matrices unidimensionales para describir las características de la estructura de almacenamiento. Recorrido de almacenamiento secuencial de tablas lineales. Es posible el acceso secuencial y el acceso aleatorio.
/*************************************************** ***** ****
> Nombre de archivo: work3.c
> Autor: Li Shang
> Fecha: 2018-08-01 15:33
****************** ******* *******************************/#include <stdio.h>
#include <stdlib.h>
#define TRUE 1 //No es necesario agregar ";" a la definición de macro
#define FALSE 0int MÁX = 10;
typedef int Elementype;// Asigne un alias a int para facilitar la modificación de una serie de tipos de datos, como typedef char Elementype
struct List//Estructura de la lista de secuencias
{ Elementype* head;//Puntero del encabezado de la lista de secuencias int length;//Longitud de la lista de secuencias };int init(struct List* l);//函数声明，后面逐个介绍
void print(struct List l);
int insert_tail(struct List* l,Valor de tipo de elemento);
int insert_index(struct List* l,int index,Valor de tipo de elemento);
int detele_index(struct Lista* l,int index);
int detele_value(struct List* l,Valor de tipo de elemento);
int updata_index(struct List* l,int index,Valor de tipo de elemento);
int query_value(struct List* l,Valor de tipo de elemento);
int vacío(struct Lista* l);int main()
{ struct List list;//Definir lista de variables de estructura int ret; ret = init(&list);//Recibir y devolver el resultado de la aplicación if(ret == FALSE) { return 1; }
int i;
for(i = 0;i < 20;i++)
{ insert_tail(&list,i);//Usa la función de inserción de cola para asignar valores a la tabla de secuencia } print(list);//Usa un personalizado función de salida para recorrer la superficie de secuencia de salidainsert_index(&lista,2,66);
imprimir(lista);
detele_index(&lista,2);
imprimir(lista);
insert_index(&lista,2,2);
imprimir(lista);
insert_index(&lista,2,66);
imprimir(lista);updata_index(&lista,2,99);
imprimir(lista);query_value(&lista,2);
lista vacía);
devolver 0;
}int init(struct List* l)//Aplica memoria para la tabla de secuencia y devuelve el resultado de la aplicación
{ l -> head = (Elementtype*)malloc(MAX*sizeof(Elementtype));//malloc se aplica a la memoria if(NULL == l -> head)//Determina si la dirección está vacía, la aplicación falla { return FALSE; } l -> length = 0;//Asigna un valor a la dirección señalada por el puntero return TRUE; }
void print(struct List l)//Función de impresión, lista de secuencia de impresión en bucle
{ int i; for(i = 0;i < l.length;i++) { printf("%d ",*(l.head+i) ); } printf("\n"); }
int insert_tail(struct List* l,Elementtype value)//Función de inserción de cola
{ if (l -> length == MAX)//Determine si la memoria es suficiente, si se alcanza el límite superior, aplique { l -> head = (Elementype*) realloc(l -> head,sizeof(Elementype)*(MAX+MAX/2));//realloc se aplica nuevamente if(NULL == l -> head)//determina si la aplicación de memoria es exitosa { return FALSE; } MAX + = MAX/2;//Calcular el tamaño de la memoria después de la aplicación printf("realloc MAX = %d\n",MAX);//Mostrar el tamaño de la memoria después de la aplicación
}
*(l -> cabeza + l -> longitud) = valor;//Asigna el valor a la longitud, es decir, el dígito después del último dígito
l -> longitud++;
devuelve VERDADERO;
}int insert_index(struct List* l,int index,Elementype value)//Insertar función en la posición especificada
{ if(l->length == MAX)//Juzga la memoria, si no es suficiente, aplica { l->head = (Elementype*)realloc (l->head,sizeof(Elementype)*(MAX += MAX/2)); if(NULL == l->head)//Determine si la solicitud se realizó correctamente { return FALSE; } MAX += MAX/2; printf("realloc MAX = %d\n",MAX );//Mostrar el tamaño después de la aplicación } if(index < 0 || index >l->length)//Juzgar si la posición de inserción se ingresó correctamente { printf("index is error\n"); return FALSE; } int i ; for(i = l->length - 1;i >= index;i--)//(crear "vacancy") asignación de bucle, asignar el dígito anterior al siguiente dígito, completar el movimiento general del valor {
*(l->cabeza + i + 1) = *(l->cabeza + i);
}
*(l->cabeza + índice) = valor;
l->longitud++;
devolver VERDADERO;}
int detele_index(struct List* l,int index)//Eliminar los datos en la posición especificada
{ if(index < 0 || index > l-> length-1)//Juzgar si la posición de inserción se ingresó correctamente { printf( "index is error \n"); return FALSE; } int i; for(i = index;i < l -> length -1;i++)//Utilice el siguiente contenido para sobrescribir el contenido anterior de una vez para completar la eliminación { *(l -> cabeza +i) = *(l -> cabeza +i +1); } l->longitud--; devuelve FALSO; }
int detele_value(struct List* l,Elementtype value)
{ int i; for(i = 0;i < l->length;i++) { if(*(l->head+i) == valor)//determinar si ¿Es el contenido especificado { detele_index(l,1); i--;// Se utiliza para determinar si la ubicación del nuevo contenido especificado cumple con los requisitos } } return TRUE; }
int updata_index(struct List* l,int index,Elementype value)
{ if(index < 0 || index > l-> length-1) { printf("el índice es error\n"); return VERDADERO; } *(l -> head +index) = value;//Sobrescribe el contenido en la posición especificada con el contenido dado return TRUE; }
int query_value(struct List* l,Elementtype value)
{ printf("query_value(%d)\n",value );//Muestra lo que estás buscando int i; int flag = 0; for(i = 0;i < l ->length;i++) { if(value == *(l->head+i))//Juzga si es el contenido especificado { flag++;//Cuenta el número que cumple con los requisitos printf("%d ",i ); } } if(flag == 0)//Determinar si no existe tal valor { printf("no found\n"); return FALSE; } printf("\n"); return TRUE; }
int vacío(struct List* l)//Libera memoria y puntero
{ free(l->head); l->head = NULL; l->length = 10; MAX = 10; return TRUE;}