链表的格式与操作示例

  链表是为克服数组的缺点，在内存空间中离散存储，但需要一个指针记住下一个结点的地址，以便可以将链表结点连接起来。

    链表与数组的比较：

  数组

                  优点：存取速度快。

                  缺点：插入和删除元素的效率很低；

                                需要一块连续的内存空间。

         链表

                  专业术语

                           首节点

                                    存放第一个有效数据的节点

                           尾节点

                                    存放最后一个有效数据的节点

                           头结点

                                    头结点的数据类型和首节点的类型是一样的（结构体变量类型）

                                    头结点是首节点前面的那个节点，头结点并不存放有效数据，

                                    设置头结点的目的是为了方便对链表的操作。

                           头指针

                                    存放头结点地址的指针变量

                           优点：插入删除元素效率高；

                                        不需要一块连续的很大的内存空间。

                           缺点：查找某个位置的元素效率低。

                  定义

                             链表的基本单元是节点，节点分为两部分：数据域和指针域，数据域用来存放有效数据，指针域存

                             放下一个节点的地址。所以链表的节点都是结构体变类型。

                             用创建链表时，链表必须为动态创建，以便其它函数对其进行操作。

                             要确定一个链表，只需链表的头指针即可，即函数参数只需一个。

链表的实现：

[cpp] view plain copy

1. # include <stdio.h>  
2. # include <malloc.h>  
3. # include <stdlib.h>  
4.   
5. struct Node //通过结构体定义节点  
6. {  
7.     int data; //创建数据域  
8.     struct Node * pNext; //创建指针域  
9. };  
10.   
11. //函数声明  
12. struct Node * CreateList(void);  
13. void TraverseList(struct Node *);  
14. bool isEmpty(struct Node *);  
15.   
16. int main(void)  
17. {  
18.     struct Node * pHead; //创建头指针，用来存放头结点的地址。  
19.   
20.     pHead = CreateList(); //CreateList()函数动态创建链表并返回头结点的地址。  
21.     printf("\n");  
22.     TraverseList(pHead); //函数参数只需头指针即可确定一个链表。  
23.   
24.     return 0;  
25. }  
26.   
27. struct Node * CreateList(void) //函数返回值为struct Node * 类型。  
28. {  
29.     int len;  
30.     int i;  
31.     int val;  
32.   
33.     struct Node * pHead = (struct Node *)malloc(sizeof(struct Node));  
34.     if (NULL == pHead)  
35.     {  
36.         printf("分配头结点空间失败，程序终止！\n");  
37.         exit(-1); //exit函数，退出程序。  
38.     }  
39.           
40.     struct Node * pTail = pHead; //创建尾指针指向尾节点  
41.     pTail->pNext = NULL;  
42.   
43.     printf("请输入链表的节点个数：len = ");  
44.     scanf("%d", &len);  
45.   
46.     for (i=0; i<len; ++i)  
47.     {  
48.         printf("请输入第%d个节点的值：", i+1);  
49.         scanf("%d", &val);  
50.   
51.         struct Node * pNew = (struct Node *)malloc(sizeof(struct Node)); //链表的不连续性在于它的内存空间在不断地一个个分配，而数组则是一次性分配完成。  
52.         if (NULL == pNew)  
53.         {  
54.             printf("分配空间失败，程序终止！\n");  
55.             exit(-1);  
56.         }  
57.   
58.         pNew->data = val;  
59.         pTail->pNext = pNew;  
60.         pNew->pNext = NULL;  
61.         pTail = pNew; //递归  
62.     }  
63.   
64.     return pHead;  
65. }  
66.   
67. void TraverseList(struct Node * pHead) //遍历输出  
68. {  
69.     struct Node * p;  
70.   
71.     if (isEmpty(pHead))  
72.     {  
73.         printf("链表为空！\n");  
74.     }  
75.     else  
76.     {  
77.         p = pHead->pNext; //使指针指向下一个节点  
78.         printf("链表中的数据为：\n");  
79.         while (NULL != p)  
80.         {  
81.             printf("%d  ", p->data);  
82.             p = p->pNext;  
83.         }  
84.         printf("\n");  
85.     }  
86.   
87.     return;  
88. }  
89.   
90. bool isEmpty(struct Node * pHead)  
91. {  
92.     if (NULL == pHead)  
93.         return true;  
94.     else  
95.         return false;  
96. }  

应用实例：学生信息管理系统

[cpp] view plain copy

1. # include <stdio.h>  
2. # include <malloc.h>  
3.   
4. struct Student  
5. {  
6.     char name[20];  
7.     int age;  
8.     float score;  
9. };  
10.   
11. void Input(struct Student *, int);  
12. void sort(struct Student *, int);  
13. void Output(struct Student *, int);  
14.   
15. int main(void)  
16. {  
17.     int len;  
18.     struct Student * pArr;  
19.   
20.     printf("请输入学生的个数：\n");  
21.     printf("len = ");  
22.     scanf("%d", &len);  
23.     pArr = (struct Student *)malloc(len*sizeof(struct Student));  
24.   
25.     Input(pArr, len);  
26.     sort(pArr, len);  
27.     printf("\n\n");  
28.     printf("排序结果是：\n");  
29.     Output(pArr, len);  
30.   
31.       
32.     return 0;  
33. }  
34.   
35. void Input(struct Student * pArr, int len)  
36. {  
37.     int i;  
38.   
39.     for (i=0; i<len; ++i)  
40.     {  
41.         printf("请输入第%d个学生的信息：\n", i+1);  
42.         printf("name = ");  
43.         scanf("%s", pArr[i].name); //结构体中name成员本身为数组，数组名name即为第一个元素的地址，不需要加&  
44.         printf("age = ");  
45.         scanf("%d", &pArr[i].age);  
46.         printf("score = ");  
47.         scanf("%f", &pArr[i].score);  
48.     }  
49. }  
50.   
51. void sort(struct Student * pArr, int len)  
52. {  
53.     int i, j;  
54.     struct Student t;  
55.   
56.     for (i=0; i<len-1; ++i)  
57.     {  
58.         for (j=0; j<len-1-i; ++j)  
59.         {  
60.             if (pArr[j].score < pArr[j+1].score)  
61.             {  
62.                 t = pArr[j];  
63.                 pArr[j] = pArr[j+1];  
64.                 pArr[j+1] = t;  
65.             }  
66.         }  
67.     }  
68. }  
69.   
70. void Output(struct Student * pArr, int len)  
71. {  
72.     int i;  
73.   
74.     for (i=0; i<len; ++i)  
75.     {  
76.         printf("第%d名学生的信息是：\n", i+1);  
77.         printf("name = ");  
78.         printf("%s",pArr[i].name);  
79.         printf("\n");  
80.         printf("age =");  
81.         printf("%d", pArr[i].age);  
82.         printf("\n");  
83.         printf("score = ");  
84.         printf("%f", pArr[i].score);  
85.         printf("\n");  
86.     }  
87. }