El lenguaje C realiza la operación básica de inicialización, adición, eliminación, verificación y modificación de listas enlazadas individualmente.
introducción
definición
★★★La lista de enlace único es una estructura de datos para el acceso en cadena de la lista lineal, que utiliza un grupo de unidades de almacenamiento con direcciones arbitrarias para almacenar datos en la lista lineal.
principio
<1> Los datos en la lista enlazada están representados por nodos y la composición de los nodos: campo de datos + campo de puntero.
<2> El campo de datos es la unidad de almacenamiento para almacenar datos, y el campo de puntero es la dirección del nodo subsiguiente.
ventaja
<1> Cuando una lista enlazada individualmente inserta o elimina un elemento, solo necesita cambiar su elemento predecesor y el puntero del elemento insertado o eliminado.
<2> Cuando se desconoce la cantidad de datos almacenados, la lista de enlaces individuales abre un espacio para cada dato almacenado, por lo que el espacio se puede captar bien y el desperdicio no será tan obvio.
defecto
<1> La lista de enlaces individuales no admite el acceso aleatorio, por lo que la eficiencia de la búsqueda es lenta.
<2> Cuando se conoce la cantidad de datos a los que se debe acceder, debido a que cada dato en la lista enlazada individualmente también incluye un campo de puntero, el desperdicio de espacio es grave. Además, para la lista de enlaces únicos, cada dirección de datos se abre aleatoriamente, por lo que el espacio de almacenamiento se fragmentará y habrá muchos espacios fragmentados pequeños.
Comparar
Haga clic en el enlace a continuación para consultar el artículo anterior y comparar la lista enlazada única y la lista secuencial.
Enlaces: ★★★ enlace .
a tiempo
<1> La estructura de la tabla de secuencias es como una matriz, y se puede acceder a sus elementos mediante subíndices, por lo que los datos de la tabla de secuencias admiten el acceso aleatorio; en contraste, los datos de la lista de enlaces individuales se almacenan en una cadena, y sus Elementos no admiten el acceso aleatorio.Si desea conocer un elemento, solo puede recorrer toda la lista vinculada desde el nodo principal hasta encontrar el elemento. Por lo tanto, la complejidad de tiempo para acceder a elementos aleatorios en una lista secuencial es O(1), y la complejidad de tiempo promedio para acceder a elementos aleatorios en una lista enlazada es O(n).
<2> Los elementos de la tabla de secuencia se almacenan continuamente. Por lo tanto, para insertar o eliminar un elemento en una posición específica, todos los elementos posteriores deben moverse hacia atrás o hacia adelante por un elemento, lo que lleva mucho tiempo; mientras que la lista enlazada única se inserta o elimina Al eliminar un elemento, solo necesita cambiar su elemento predecesor y la dirección del elemento insertado o eliminado. Por lo tanto, la complejidad temporal promedio de insertar y eliminar elementos en una posición aleatoria en una lista secuencial es O(n), y la complejidad temporal de insertar y eliminar elementos en una posición aleatoria en una lista enlazada es O(1)
en el espacio
<1> El espacio de la tabla de secuencias generalmente se abre continuamente, y el espacio para almacenar múltiples elementos se abrirá al mismo tiempo, por lo que cuando se usa la tabla de secuencias, se pueden escribir múltiples datos en el caché al mismo tiempo, y luego se escribe en la memoria principal, la tabla de secuencias La memoria caché de la CPU es más eficiente y la canalización de la CPU no siempre se interrumpirá; y la lista enlazada individualmente solo abre espacio cada vez que se necesita almacenar datos, por lo que cada almacenamiento de datos debe escribirse en el área de la memoria caché por separado. Luego, escribir en la memoria principal, lo que hace que la eficiencia de la memoria caché de la CPU de la lista enlazada única sea baja y la canalización de la CPU a menudo se interrumpa.
<2> El hecho de que se conozca la cantidad de datos también afectará la selección y el uso de listas enlazadas individualmente y listas secuenciales. Este punto de vista se puede establecer a la luz de los pros y los contras anteriores.
Proceso experimental y resultados.
el código
//<库函数>
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<math.h>
//<相关参数的宏定义>
#define Len sizeof(Node)
typedef int Elemtype;
typedef struct Node
{
Elemtype data;
struct Node* next;
}Node;
typedef struct Node Linklist;
//<单链表的初始化、增删查改、输出函数的定义>
Linklist* Creat_L();
void Out_Linklist(Linklist *h);
void Insert_List(Linklist *L,int i,Elemtype x);
void Delete_List(Linklist *L,int i);
void Found_List(Linklist *L,Elemtype x);
void Amend_List(Linklist *L,int i,Elemtype x);
// <主函数>
void main()
{
Linklist *L;
int k ;
int i ;
Elemtype x;
printf(" 《 Welcome to use the founction 》\n");
printf(" The founction can offer following service\n");
printf(" *******Please first Initlist*******\n\n");
printf(" 1、Initlist ->初始化单链表\n");
printf(" 2、Insertlist ->插入操作\n");
printf(" 3、Deletelist ->删除操作\n");
printf(" 4、Foundlist ->查找操作\n");
printf(" 5、Amendlist ->更改操作\n");
printf(" 0、Exitlist ->退出操作\n\n\n");
printf(" Please choose following digital：1、2、3、4、5、0\n");
printf(" Finish your idea!!!!!!\n");
do
{
printf("\n\nPlease Input your choice：");
scanf("%d",&k);
switch(k)
{
case 1:
{
L = Creat_L();
Out_Linklist(L);
}break;
case 2:
{
printf("Input the position of Insert：");
scanf("%d",&i);
printf("Input the data of Insert：");
scanf("%d",&x);
Insert_List(L,i,x);
Out_Linklist(L);
}break;
case 3:
{
printf("Input the position of Delete：");
scanf("%d",&i);
Delete_List(L,i);
Out_Linklist(L);
}break;
case 4:
{
printf("Input the data of Found：");
scanf("%d",&x);
Found_List(L,x);
//Out_Linklist(L);
}break;
case 5:
{
printf("Input the position of Amend：");
scanf("%d",&i);
printf("Amend data to：");
scanf("%d",&x);
Amend_List(L,i,x);
Out_Linklist(L);
}break;
}
}while(k!=0);
}
// <初始化函数>
Linklist* Creat_L()
{
//int i;
Linklist *h,*p,*s;
Elemtype x;
h = (Node*)malloc(Len);
h->next = NULL;
p = h;
printf("Please Enter the FIRST Node data： ");
scanf("%d",&x);
while(x!=99) //假设终止条件
{
s = (Node*)malloc(Len);
s->data = x; //赋值
s->next = NULL;
p->next = s;
p = s;
printf("Please Enter the NEXT Node data： ");
scanf("%d",&x);
}
return h;
}
//<输出函数>
void Out_Linklist(Linklist *h)
{
Linklist *p;
p = h->next;
printf("Output Linklist：");
while(p)
{
if(p->next!=NULL)
{
printf("%d -> ",p->data);
p = p->next;
}
else
{
printf("%d",p->data);
p = p->next;
}
}
}
//<插入函数>
void Insert_List(Linklist *L,int i,Elemtype x)
{
int j;
Linklist *p,*s;
p = L;
if(i<0)
{
printf("The position is unreasonable!!!!!!!!!\n");
printf("Please Input Again!!!!!!!\n");
exit(0);
}
for(j=0;j<=i;j++)
{
if(j == i)
{
s = (Node*)malloc(Len); //声明一个新节点 s ，并填充相关数据，插入链表
s->data = x;
s->next = p->next;
p->next = s;
break;
}
p = p->next;
}
}
// <删除函数>
void Delete_List(Linklist *L,int i)
{
Linklist *p,*s;
int j;
Elemtype x;
p = L;
if(i<0||p->next == NULL)
{
printf("The position is unreasonable!!!!!!!!!\n");
printf("Please Input Again!!!!!!!\n");
exit(0);
}
for(j=0;j<=i;j++)
{
if(j==i)
{
s = p->next; //定义变量 s 指向牺牲节点，并释放
x = s->data;
p->next = s->next;
free(s);
}
p = p->next;
}
}
// <查找函数>
void Found_List(Linklist *L,Elemtype x)
{
Linklist *p;
int i = 0;
p = L;
while(p)
{
if(p->data == x)
{
printf("Found data in %d position\n",i);
break;
}
else
{
i++;
p = p->next;
}
}
if(p==NULL)
printf("Sorry , The data is not in the Linklist!!!!!!\n");
}
//<修改函数>
void Amend_List(Linklist *L,int i,Elemtype x)
{
Linklist *p;
int j = 0;
p = L;
while(p)
{
if(j == i)
{
p->data = x;
break;
}
else
{
j++;
p = p->next;
}
}
if(p==NULL)
printf("The position of inputting is incorrect!!!!!!\n");
}
resultado de la operación
★★★Las operaciones básicas de inicialización, adición, eliminación, verificación y modificación se completan sucesivamente★★★
Resumir
Para resumir lo anterior, la lista secuencial y la lista enlazada simple tienen sus propias ventajas y desventajas, cuál es mejor usar depende de problemas específicos y no se puede generalizar.