C语言链表专题复习
链表专题复习
数组作为存放同类数据的集合，给我们在程序设计时带来很多的方便，增加了灵活性。但数组也同样存在一些弊病。如数组的大小在定义时要事先规定，不能在程序中进行调整，这样一来，在程序设计中针对不同问题有时需要3 0个元素大小的数组，有时需要5 0个数组元素的大小，难于统一。我们只能够根据可能的最大需求来定义数组，常常会造成一定存储空间的浪费。
我们希望构造动态的数组，随时可以调整数组的大小，以满足不同问题的需要。链表就是我们需要的动态数组。它是在程序的执行过程中根据需要有数据存储就向系统要求申请存储空间，决不构成对存储区的浪费。
链表是一种复杂的数据结构，其数据之间的相互关系使链表分成三种：单链表、循环链表、双向链表，下面只介绍单向链表。
7.4.1 单链表
图7 - 3是单链表的结构。
单链表有一个头节点h e a d，指向链表在内存的首地址。链表中的每一个节点的数据类型为结构体类型，节点有两个成员：整型成员（实际需要保存的数据）和指向下一个结构体类型节点的指针即下一个节点的地址（事实上，此单链表是用于存放整型数据的动态数组）。链表按此结构对各节点的访问需从链表的头找起，后续节点的地址由当前节点给出。无论在表中访问那一个节点，都需要从链表的头开始，顺序向后查找。链表的尾节点由于无后续节点，其指针域为空，写作为N U L L。
图7 - 3还给出这样一层含义，链表中的各节点在内存的存储地址不是连续的，其各节点的地址是在需要时向系统申请分配的，系统根据内存的当前情况，既可以连续分配地址，也可以跳跃式分配地址。
看一下链表节点的数据结构定义：
struct node
{
int num;
struct node *p;
} ;
在链表节点的定义中，除一个整型的成员外，成员p是指向与节点类型完全相同的指针。
在链表节点的数据结构中，非常特殊的一点就是结构体内的指针域的数据类型使用了未定义成功的数据类型。这是在C中唯一规定可以先使用后定义的数据结构。
?单链表的创建过程有以下几步：
1 ) 定义链表的数据结构。
2 ) 创建一个空表。
3 ) 利用m a l l o c ( )函数向系统申请分配一个节点。
4 ) 将新节点的指针成员赋值为空。若是空表，将新节点连接到表头；若是非空表，将新
节点接到表尾。
5 ) 判断一下是否有后续节点要接入链表，若有转到3 )，否则结束。
?单链表的输出过程有以下几步
1) 找到表头。
2) 若是非空表，输出节点的值成员，是空表则退出。
3 ) 跟踪链表的增长，即找到下一个节点的地址。
4) 转到2 )。
下列是用尾插法创建链表
新开辟的节点总是插在表末
[例7-5] 创建一个存放正整数（输入负数时做结束标志）的单链表，并打印输出。#include
#include
struct node /*链表节点的结构* /
{
int num;
struct node *next; } ;
m a i n ( )
{
struct node *creat(); / *函数声明* /
void print();
struct node *head; / * 定义头指针* /
head=NULL;/*建一个空表*/
head=creat(head);/*创建单链表*/
print(head);/*打印单链表*/ }
/******************************************/
struct node*creat(structnode*head)函/数*返回的是与节点相同类型的指针*/ {
struct node*p1,*p2;
p1=p2=(structnode*)malloc(sizeof(structnode));申请/*新节点*/
scanf("%d",&p1->num);/*输入节点的值*/
p1->next=NULL;/*将新节点的指针置为空*/
while(p1->num>0)/*输入节点的数值大于0*/
{
if(head==NULL)head=p1;/*空表，接入表头*/
elsep2->next=p1;/*非空表，接到表尾*/
p2=p1;
p1=(structnode*)malloc(sizeof(structnode));申/请*下一个新节点*/
scanf("%d",&p1->num);/*输入节点的值*/
}
return head;/*返回链表的头指针*/ }
/*******************************************/
void print(struct node*head)输/*出以head为头的链表各节点的值*/
{
struct node *temp;
temp=head;/*取得链表的头指针*/
while(temp!=NULL)/*只要是非空表*/
{
printf("%6d",temp->num);/*输出链表节点的值*/
temp=temp->next;/*跟踪链表增长*/ } }
在链表的创建过程中，链表的头指针是非常重要的参数。因为对链表的输出和查找都要从链表的头开始，所以链表创建成功后，要返回一个链表头节点的地址，即头指针。
下列是用头插法创建链表
新开辟的结点总是作为表头结点
程序清单位：
#include
#include
struct node
{ int num;
struct node *next; };
struct node *creat(struct node *head)
{ struct node *top; /*top为新开辟的结点*/
top=(struct node *)malloc(sizeof(struct node));
scanf(“%d”,&top->num);
while(top->num>=0)
｛
top->next=head; /*原来的第一个结点接在新开辟的结点后面*/
head=top; /*新开辟结点作表头结点，也就是说插在表头*/
top=(struct node *)malloc(sizeof(struct node));
scanf(“%d”,&top->num); }
return head; }
7.4.2 单链表的插入与删除
在链表这种特殊的数据结构中，链表的长短需要根据具体情况来设定，当需要保存数据时向系统申请存储空间，并将数据接入链表中。对链表而言，表中的数据可以依此接到表尾或连结到表头，也可以视情况插入表中；对不再需要的数据，将其从表中删除并释放其所占空间，但不能破坏链表的结构。这就是下面将介绍的链表的插入与删除。
1. 链表的删除
在链表中删除一个节点，用图7 - 4描述如下：
[例7-6] 创建一个学生学号及姓名的单链表，即节点包括学生学号、姓名及指向下一个节点的指针，链表按学生的学号排列。再从键盘输入某一学生姓名，将其从链表中删除。
首先定义链表的结构：
从图7 - 4中看到，从链表中删除一个节点有三种情况，即删除链表头节点、删除链表的中间节点、删除链表的尾节点。题目给出的是学生姓名，则应在链表中从头到尾依此查找各节点，并与各节点的学生姓名比较，若相同，则查找成功，否则，找不到节点。由于删除的节点可能在链表的头，会对链表的头指针造成丢失，所以定义删除节点的函数的返回值定义为返回结构体类型的指针。struct node *delet(struct node *head,char *pstr)
/*he a d 为头指针，删除ps t r 所在节点*/
{
struct node *temp,*p;
t e m p = h e a d ; / * 链表的头指针* /
if (head==NULL) / *链表为空* /
printf("\nList is null!\n");
else /*非空表* /
{
t e m p = h e a d ;
while (strcmp(temp->str,pstr)!=0&&temp->next!=NULL)
/ * 若节点的字符串与输入字符串不同，并且未到链表尾* /
{
p = t e m p ;
t e m p = t e m p - > n e x t ; / * 跟踪链表的增长，即指针后移* /
}
if(strcmp(temp->str,pstr)==0 ) / *找到字符串* /
{
if(temp==head) { / * 表头节点* /
printf("delete string :%s\n",temp->str);
h e a d = h e a d - > n e x t ;
f r e e ( t e m p ) ; / *释放被删节点* /
}
e l s e
{
p->next=temp->next; /*表中节点*/
printf("delete string :%s\n",temp->str);
f r e e ( t e m p ) ;
} }
else printf("\nno find string!\n"); /*没找到要删除的字符串*/
}
r e t u r n ( h e a d ) ; / *返回表头指针* / }
2. 链表的插入
首先定义链表的结构：
struct
{ int num; /*学生学号* /
char str[20]; /*姓名* /
struct node *next; } ;
在建立的单链表中，插入节点有三种情况，如图7 - 5所示。
插入的节点可以在表头、表中或表尾。假定我们按照以学号为顺序建立链表，则插入的节点依次与表中节点相比较，找到插入位置。由于插入的节点可能在链表的头，会对链表的头指针造成修改，所以定义插入节点的函数的返回值定义为返回结构体类型的指针。节点的插入函数如下：
struct node *insert(head,pstr,n) / *插入学号为n、姓名为p s t r 的节点* / struct node *head; / *链表的头指针* /
char *pstr;
int n;
{ struct node *p1,*p2,*p3;
p1=(struct node*)malloc(sizeof(struct node))分;配/*一个新节点*/
s t r c p y ( p 1 - > s t r , p s t r ) ; / * 写入节点的姓名字串* /
p 1 - > n u m = n ; / * 学号* /
p 2 = h e a d ;
if (head==NULL) / * 空表* /
{
head=p1; p1->next=NULL;/ *新节点插入表头* /
}
e l s e
{ /*非空表* /
while(n>p2->num&&p2->next!=NULL)
/ *输入的学号小于节点的学号，并且未到表尾* /
{
p 3 = p 2 ;
p 2 = p 2 - > n e x t ; / * 跟踪链表增长* /
}
if (n<=p2->num) / *找到插入位置* /
if (head==p2) / * 插入位置在表头* /
{
h e a d = p 1 ;
p 1 - > n e x t = p 2 ;
}
e l s e
{ /*插入位置在表中* /
p 3 - > n e x t = p 1 ;
p 1 - > n e x t = p 2 ;
}
e l s e
{ /*插入位置在表尾* /
p 2 - > n e x t = p 1 ;
p 1 - > n e x t = N U L L ;
}
}
r e t u r n ( h e a d ) ; / * 返回链表的头指针* / }
3. 实例[例7 - 7 ]
创建包含学号、姓名节点的单链表。其节点数任意个，表以学号为序，低学号的在前，高学号的在后，以输入姓名为空作结束。在此链表中，要求删除一个给定姓名的节点，并插入一个给定学号和姓名的节点。
# include "stdlib.h"
# include "malloc. h"
struct node /*节点的数据结构* /
{
int num;
char str[20];
struct node *next; } ;
main( )
{ / *函数声明* /
struct node *creat();
struct node *insert();
struct node *delet();
void print( );
struct node *head;
char str[20];
int n;
head=NULL; /*做空表* /
head=creat (head); / *调用函数创建以head 为头的链表* / p r i n t ( h e a d ) ；/ *调用函数输出节点* /
printf("\n input inserted num,name:\n");
gets(str); /*输入学号* /
n=atoi (str);
gets(str); /*输入姓名* /
head=insert (head, str, n); 将/*节点插入链表*/
print (head)；/ *调用函数输出节点*/
printf("\n input deleted name:\n");
gets(str); /*输入被删姓名* /
head=delet(head,str); /调*用函数删除节点*/
print (head); /*调用函数输出节点* /
r e t u r n ; }
/ * * * 创建链表* * * * * * * * * * * * /
struct node *creat(struct node *head)
{
char temp[30];
struct node *pl,*p2;
pl=p2=(struct node*) malloc(sizeof(struct node));
printf ("input num, name: \n;")
printf("exit:double times Enter!\n");
g e t s ( t e m p ) ;
gets (p1->str);
pl->num=atoi (temp);
p l - > n e x t = N U L L ;
while (strlen (pl->str)>0
{
if (head==NULL) head=pl；
else p2->next=p1;
P 2 = p l ；
pl=(struct node *)malloc(sizeof(struct node));
printf ("input num, name: \n");
printf("exit:double times Enter!\n");
g e t s ( t e m p ) ;
gets(pl ->str);
p1->num=atoi (temp);
p1 - > n e x t = N U L L ; }
return head; }
/ * * * * * * * * * * 插入节点* * * * * * * * * * / struct node *insert (head, pstr,n);
struct node *head;
char *pstr;
int n;
{ struct node *pl,*p2,*p3;
p1=(struct node*)malloc(sizeof(struct node)); strcpy (p1->str, pstr);
p 1 - > n u m = n ;
p 2 = h e a d ;
i f ( h e a d = = N U L L )
{
h e a d = p l ; p l - > n e x t = N U L L ;
}
e l s e
{
while (n>p2->num&&p2->next!=NULL)
{
p 3 = P 2
p 2 = p 2 - > n e x t ; }
if (n<=p2->num)
if (head==p2)
{
h e a d = p l ;
p l - > n e x t = p 2 ; }
else
{
p 3 - > n e x t = p l ;
p l - > n e x t = p 2 ; }
else
{
p 2 - > n e x t = p l ;
p l - > n e x t = N U L L ;
} }
r e t u r n ( h e a d ) ; }
/ * * * * * 删除节点* * * * * * * * * * * * * / struct node *delet (struct node *head, char *pstr) {
struct node *temp,*p;
t e m p = h e a d ;
if (head==NULL)
printf("\nList is null!\n");
else
{ t e m p = h e a d ;
while (strcmp(temp->str,pstr)!=O&&temp->next!=NULL)
{
p = t e m p ;
t e m p = t e m p - > n e x t ,
}
i f ( s t r c m p ( t e m p - > s t r , p s t r ) = = 0 )
{
if (temp== head)
{
h e a d = h e a d - > n e x t ;
f r e e ( t e m p ) ;
}
else
{
p->next =temp->next;
printf("delete string :%s\n",temp->str);
f r e e ( t e m p ) ;
} }
else printf("\nno find string!\n");
}
return(head); }
/ * * * * * * * * * * 链表各节点的输出* * * * * * * * * * /
void print (struct node *head)
{
struct node *temp;
t e m p = h e a d ;
while (temp!=NULL)
{
p r i n t f ( " \ n % d - - - - % s \ n " , t e m p - > n u m ，t e m p - > s t r ) ；
t e m p = t e m p - > n e x t ；}
r e t u r n ; }
带头结点与不带头结点链表的区别：
题目中没说明，就当不带头结点，除非明确规定了带头结点。
带头结点的链表的第一个结点没有数据域，只有指针域。例如要计算链表中所有结点数据的和，应定义一个指向结构体结点的指针，指向链表的第一个含数据的结点，给它赋值时，
应是 struct node *p=head->next; 其中head为链表的头指针。因为头结点不含数据，头结点指向的结点才开始带数据。如果是不带头结点的链表，第一个结点就含数据，因此，给它赋值时，应是struct node *p=head;
附：常见算法用链表实现
1.查找算法
例：如果有如下链表结构：
struct st
｛ char name[20]; /*学生姓名*/
int cj; /*学生成绩*/
struct st *next; };
如果链表已创建正确，要求输入一个学生姓名，查找该生成绩，并输出该生姓名，成绩，以及该生在链表中的位置（第几个结点）
struct st *search(struct st *h,char *x)
{ struct st *p=h;
int flag=0,position=0;
while(p!=NULL)
{ position++；
if(strcmp(p->name,x)==0) {flag=1；break;}
p=p->next; }
if(flag==1)
{printf(“在链表中的第%d个结点”,position);
return p; } /*找到了，返回该结点的地址*/
else
{ printf(“no found!”); return ;} ｝
main()
{ struct st *q,*head;
char xm[20];
gets(xm);
head=creat(NULL); /*链表已创建，题目已规定，创建链表过程省略*/ q=search(head,xm);
printf(“%s: %d\n”,q->name,q->cj); }
2.排序算法
欲将链表中结点的成绩从大到小排列输出。
#include
#include
struct st
{ int cj;
struct st *link; };
void sort(struct st *head)
{
struct st *p,*q;
int t;
for(p=head;p!=NULL;p=p->link)
for(q=p->link;q!=NULL;q=q->link)
if(q->cj>p->cj) {t=p->cj;p->cj=q->cj;q->cj=t;} }
注意：由于链表中结点在内存中是不连续的，故不可使用p++(指针自增，指向链表的下一个结点)，只能通过p=p->link指向下一个结点。单向链表只能从当前结点找到表尾方向的下一个结点，不可从当前结点找到表头方向的前一个结点。因为当前结点只存放了下一个结点的地址。
c语言链表解析
c语言链表解析 编程思想： 链表由一系列不必在内存中相连的结构组成。每一个结构均含有表元素和指向包含该元素后继元的结构指针。我们称之为next指针。最后一个单元的next指针指向NULL；该值由C定义并且不能与其它指针混淆。ANSI C规定NULL为零。 指针变量是包含存储另外某个数据的地址的变量。因此，如果P被声明为指向一个结构的指针，那么存储在P中的值就被解释为内存中的一个位置，在该位置能够找到一个结构。该结构的一个域可以通过P->FileName访问，其中FileName是我们要考察的域的名字。如图1所示，这个表含有五个结构，恰好在内存中分配给它们的位置分别是1000，800,712,992和692。第一个结构的指针含有值800，它提供了第二个结构所在的位置。其余每个结构也都有一个指针用于类似的目的。当然，为了访问该表，我们需要知道在哪里能够找到第一个单元。 图1 为了执行打印表PrinList（L）或查找表Find（L，key），只要将一个指针传递到该表的第一个元素，然后用一些Next指针穿越该表即可。 删除命令可以通过修改一个指针来实现。图2给出在原表中删除第三个元素的结果。 图2 插入命令需要使用一次malloc调用从系统得到一个新单元并在此后执行两次指针调整。想法通过图3给出，其中虚线表示原来的指针。 图3
程序设计： 上面的描述实际上足以使每一部分都能正常工作，但还是有几处地方可能会出问题： 1、并不存在从所给定义出发在表的前面插入元素的真正显性的方法。 2、从表的前面实行删除是一个特殊情况，因为它改变了表的起始端；编程的疏忽将会造成表的丢失。 3、在执行删除命令时，要求我们记住被删除元素前面的表元。 事实上，稍作一个简单的变化就能够解决所有这三个问题。做一个标志节点——表头（header）。图4表示一个带头头结点的链表。 图4 为了避免删除操作相关的一些问题，我们需要编写一个FindPrevious函数，它将返回我们要删除的表元的前驱元的位置。如果我们使用表头，那么当删除表的第一个元素时，FindPrevious将返回表头的位置。 代码实现： 按照C的约定，作为类型的List（表）和Position（位置）以及函数的原型都列在所谓的.h 头文件中。具体的Node（节点）声明则在.c文件中。 代码1、链表的类型声明 #ifndef _List_H struct Node; typedef struct Node *PtrToNode; typedef PtrToNode List; typedef PtrToNode Posotion; List MakeEmpty(List L); int IsEmpty(List L); int IsLast（Position P， List L）； Position Find(ElementType X, List L); void Delete(ElementType X, List L); Position FindPrevious(ElementType X, List L); void Insert(ElementType X, List L, Position P); void DeleteList(List L); struct Node { ElementType Elment; Position Next; } 代码2、测试一个链表是否是空表的函数。（头结点的Next指向NULL时为空链表）
C语言链表专题复习
链表专题复习 数组作为存放同类数据的集合，给我们在程序设计时带来很多的方便，增加了灵活性。但数组也同样存在一些弊病。如数组的大小在定义时要事先规定，不能在程序中进行调整，这样一来，在程序设计中针对不同问题有时需要3 0个元素大小的数组，有时需要5 0个数组元素的大小，难于统一。我们只能够根据可能的最大需求来定义数组，常常会造成一定存储空间的浪费。 我们希望构造动态的数组，随时可以调整数组的大小，以满足不同问题的需要。链表就是我们需要的动态数组。它是在程序的执行过程中根据需要有数据存储就向系统要求申请存储空间，决不构成对存储区的浪费。 链表是一种复杂的数据结构，其数据之间的相互关系使链表分成三种：单链表、循环链表、双向链表，下面只介绍单向链表。 7.4.1 单链表 图7 - 3是单链表的结构。 单链表有一个头节点h e a d，指向链表在内存的首地址。链表中的每一个节点的数据类型为结构体类型，节点有两个成员：整型成员（实际需要保存的数据）和指向下一个结构体类型节点的指针即下一个节点的地址（事实上，此单链表是用于存放整型数据的动态数组）。链表按此结构对各节点的访问需从链表的头找起，后续节点的地址由当前节点给出。无论在表中访问那一个节点，都需要从链表的头开始，顺序向后查找。链表的尾节点由于无后续节点，其指针域为空，写作为N U L L。 图7 - 3还给出这样一层含义，链表中的各节点在内存的存储地址不是连续的，其各节点的地址是在需要时向系统申请分配的，系统根据内存的当前情况，既可以连续分配地址，也可以跳跃式分配地址。 看一下链表节点的数据结构定义： struct node { int num; struct node *p; } ; 在链表节点的定义中，除一个整型的成员外，成员p是指向与节点类型完全相同的指针。 在链表节点的数据结构中，非常特殊的一点就是结构体内的指针域的数据类型使用了未定义成功的数据类型。这是在C中唯一规定可以先使用后定义的数据结构。 ?单链表的创建过程有以下几步： 1 ) 定义链表的数据结构。 2 ) 创建一个空表。 3 ) 利用m a l l o c ( )函数向系统申请分配一个节点。
C语言版用链表实现通讯录
C语言版用链表实现通讯录 “标头.h” #include
#include
C语言链表
链表的c语言实现（一） 准备：动态内存分配 一、为什么用动态内存分配 但我们未学习链表的时候，如果要存储数量比较多的同类型或同结构的数据的时候，总是使用一个数组。比如说我们要存储一个班级学生的某科分数，总是定义一个float型（存在0.5分）数组： float score[30]; 但是，在使用数组的时候，总有一个问题困扰着我们：数组应该有多大？ 在很多的情况下，你并不能确定要使用多大的数组，比如上例，你可能并不知道该班级的学生的人数，那么你就要把数组定义得足够大。这样，你的程序在运行时就申请了固定大小的你认为足够大的内存空间。即使你知道该班级的学生数，但是如果因为某种特殊原因人数有增加或者减少，你又必须重新去修改程序，扩大数组的存储范围。这种分配固定大小的内存分配方法称之为静态内存分配。但是这种内存分配的方法存在比较严重的缺陷，特别是处理某些问题时：在大多数情况下会浪费大量的内存空间，在少数情况下，当你定义的数组不够大时，可能引起下标越界错误，甚至导致严重后果。 那么有没有其它的方法来解决这样的外呢体呢？有，那就是动态内存分配。 所谓动态内存分配就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不象数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。从以上动、静态内存分配比较可以知道动态内存分配相对于景泰内存分配的特点： 1、不需要预先分配存储空间； 2、分配的空间可以根据程序的需要扩大或缩小。 二、如何实现动态内存分配及其管理 要实现根据程序的需要动态分配存储空间，就必须用到以下几个函数 1、malloc函数 malloc函数的原型为： void *malloc (unsigned int size) 其作用是在内存的动态存储区中分配一个长度为size的连续空间。其参数是一个无符号整形数，返回值是一个指向所分配的连续存储域的起始地址的指针。还有一点必须注意的是，当函数未能成功分配存储空间（如内存不足）就会返回一个N ULL指针。所以在调用该函数时应该检测返回值是否为NULL并执行相应的操作。下例是一个动态分配的程序： #include #include main() { int count,*array; /*count是一个计数器，array是一个整型指针，也可以理解为指向一个整型数组的首地址*/ if((array(int *) malloc(10*sizeof(int)))==NULL) { printf("不能成功分配存储空间。"); exit(1); } for (count=0;count〈10;count++) /*给数组赋值*/
数据结构(C语言)【经典试题库】附含答案解析
《数据结构与算法》复习题 选择题 1．在数据结构中，从逻辑上可以把数据结构分为 C 。 A．动态结构和静态结构 B．紧凑结构和非紧凑结构 C．线性结构和非线性结构 D．内部结构和外部结构 2．数据结构在计算机内存中的表示是指 A 。 A．数据的存储结构 B．数据结构 C．数据的逻辑结构 D．数据元素之间的关系 3．在数据结构中，与所使用的计算机无关的是数据的 A 结构。 A．逻辑 B．存储 C．逻辑和存储 D．物理 4．在存储数据时，通常不仅要存储各数据元素的值，而且还要存储 C 。A．数据的处理方法 B．数据元素的类型 C．数据元素之间的关系 D．数据的存储方法 5．在决定选取何种存储结构时，一般不考虑 A 。 A．各结点的值如何 B．结点个数的多少 C．对数据有哪些运算 D．所用的编程语言实现这种结构是否方便。 6．以下说法正确的是 D 。 A．数据项是数据的基本单位 B．数据元素是数据的最小单位 C．数据结构是带结构的数据项的集合 D．一些表面上很不相同的数据可以有相同的逻辑结构 7．算法分析的目的是 C ，算法分析的两个主要方面是 A 。
（1）A．找出数据结构的合理性 B．研究算法中的输入和输出的关系C．分析算法的效率以求改进 C．分析算法的易读性和文档性（2）A．空间复杂度和时间复杂度 B．正确性和简明性 C．可读性和文档性 D．数据复杂性和程序复杂性 8．下面程序段的时间复杂度是 O(n2) 。 s =0; for( I =0; i 关于C语言链表的操作实例 有这样一个结构体char team//队伍名 int jifen//积分 int win//胜利场数 int lost//失利场数 现在有N个队伍,想把一个队伍信息存入一个链表结点，可增加删除队伍，修改队伍信息，用链表具体怎么实现。本人一直对链表不太清楚，想通过此例理解链表，谢谢各位高手赐教，最好注释详细，谢谢！ 最佳答案 一般连表程序在c语言中要用link list来实现，我贴一个我写的程序在这里，可以运行，这个程序里包含一个structer纪录学生信息，学生号码已极学生姓名，纪录通过insert_node 添加，通过delete_node删除，并在最开始的时候通过create list function来创建最原始的数据，不用理会里面的reverse function。 #include C语言链表的操作实例