顺序线性表的优点：方便存取（随机的），特点是物理位置和逻辑为主都是连续的（相邻）。但是也有不足，比如；前面的插入和删除算法，需要移动大量元素，浪费时间，那么链式线性表 (简称链表) 就能解决这个问题。
一般链表的存储方法
一组物理位置任意的存储单元来存放线性表的数据元素，当然物理位置可以连续，也可以不连续，或者离散的分配到内存中的任意位置上都是可以的。故链表的逻辑顺序和物理顺序不一定一样。
因为，链表的逻辑关系和物理关系没有必然联系，那么表示数据元素之间的逻辑映象就要使用指针，每一个存储数据元素的逻辑单元叫结点（node）。
结点里有两个部分，前面存储数据元素内容，叫数据域，后面部分存储结点的直接后继在内存的物理位置，叫指针域。那么就可以实现用指针（也叫链）把若干个结点的存储映象链接为表，就是链式线性表。
上面开始介绍的是最简单的链表，因为结点里只有一个指针域，也就是俗称的单链表（也叫线性链表）。
单链表可以由一个叫头指针的东东唯一确定，这个指针指向了链表（也就是直接指向第一个结点）。因此单链表可以用头指针的名字来命名。且最后一个结点指针指向NULL。
链表类别
1、实现的角度：动态链表，静态链表（类似顺序表的动态和静态存储）
2、链接方式的角度：单链表，双向链表，循环链表
单链表
单链表的头结点
一般是使用单链表的头指针指向链表的第一个结点，有的人还这样做，在第一个结点之前再加一个结点（不保存任何数据信息，只保存第一个结点的地址，有时也保存一些表的附加信息，如表长等），叫头结点（头结点是头结点，第一个结点是第一个结点）。那么此时，头指针指向了头结点。并且有无头结点都是可以的。链表还是那个链表，只不过表达有差异。
那么问题来了！为什么还要使用头结点？
作用是对链表进行操作时，可以对空表、非空表的情况以及对首元结点进行统一处理，编程更方便。
描述动态单链表
有两种做法，一种是传统的动态链表结构，暨只定义结点的存储结构，使用4个字节的指针变量表示线性表。还有一种是直接采用结构体变量（类似顺序表）来表示线性表。
顾名思义，肯定是第二种方法比较方便。
先看传统存储动态单链表结构的操作
1 /************************************************************************/
2 /* 文件名称：ADT.h
3 /* 文件功能：动态单链表传统存储结构和常见操作
4 /* 作 者：dashuai
5 /* 备 注：以下算法，并没有考证是否全部都是最佳优化的，关于算法的优化后续研究
6 /************************************************************************/
7 #include <stdio.h>
8 #include <stdlib.h>
9
10 //传统的单链表动态存储结构（带头指针）
11 typedef struct Node//Node标记可以省略，但如结构里声明了指向结构的指针，那么不能省略！
12 {
13 char data;//数据域
14 struct Node *next;//指针域
15 } Node, *LinkList;//LinkList是指向Node结构类型的指
16
17 /*
18 1、查找（按值）算法
19 找到第一个值等于value的结点，找到则返回存储位置
20 */
21 LinkList getElemByValue(LinkList L, char value);
22
23 /*
24 2、查找（按序号）算法
25 查找第i个元素，并用变量value返回值，否则返回提示，即使知道了序号，也必须使用指针顺次查访
26 */
27 void getElemByNum(LinkList L, int num, char *value);
28
29 /*
30 3、删除结点
31 删除元素，并用value返回值
32 */
33 void deleteList(LinkList L, int i, char *value);
34
35 /*
36 4、插入结点
37 在第i个位置之前插入结点e
38 */
39 void insertList(LinkList L, int i, char value);
40
41 /*
42 5、头插法建立单链表（逆序建表）
43 从一个空结点开始，逐个把 n 个结点插入到当前链表的表头
44 */
45 void createListByHead(LinkList *L, int n);
46
47 /*
48 6、尾插法建立单链表（顺序建表）
49 从一个空结点开始，逐个把 n 个结点插入到当前链表的表尾
50 */
51 void createListByTail(LinkList *L, int n);
52
53 /*
54 7、尾插法建立有序单链表（归并链表）
55 把两个有序（非递减）链表LA LB合并为一个新的有序（非递减）链表LC(空表)
56 要求：不需要额外申请结点空间来完成
57 */
58 void mergeListsByTail(LinkList LA, LinkList LB, LinkList LC);
59
60 /*
61 8、销毁单链表
62 */
63 void destoryLinkList(LinkList *L);
64
65 /*
66 9、求表长，长度保存到头结点
67 */
68 void getLength(LinkList L);
69
70 /*
71 10、遍历单链表
72 */
73 void traversalList(LinkList L);
C变量的随用随定义，可以确定C99之后新增加的，和c++一样，貌似一些编译器还不支持
1 #include "ADT.h"
2
3 /*
4 1、查找（按值）算法
5 找到第一个值等于value的结点，找到则返回存储位置
6 */
7 LinkList getElemByValue(LinkList L, char value)
8 {
9 //定义指示指针指向L第一个结点
10 LinkList p = L->next;//L开始指向了头结点，L->next指向的就是第一个结点
11
12 while (p && p->data != value)
13 {
14 //p++;显然错误，离散存储，非随机结构
15 p = p->next;//指针顺链移动，直到找到或者结束循环
16 }
17 //当找不到，则p最终指向NULL，循环结束
18 return p;//返回存储位置或NULL
19 }
算法执行时间和value有关，时间复杂度为0（n），n表长
1 /*
2 2、查找（按序号）算法
3 查找第i个元素，并用变量value返回值，否则返回提示，即使知道了序号，也必须使用指针顺次查访
4 */
5 void getElemByNum(LinkList L, int num, char *value)
6 {
7 int count = 1;
8 LinkList p = L->next;
9 //控制指针p指向第num个结点
10 while (p && count < num)//num若为0或者负数直接跳出循环，若超出表长则遍历完毕，跳出循环，找到了元素也跳出循环
11 {
12 p = p->next;//p指向第num个结点，count此时为num值
13 count++;
14 }
15 //如果num大于表长，则count值增加到表长度时，p恰好指向表尾结点，遍历完整个链表也找不到结点，此时再循环一次
16 //p指向null，count = 表长 + 1，循环结束，这里也隐含说明了num大于 表长 的不合法情况
17 if (!p || count > num)//说明num至少比 表长 大
18 {
19 //num <= 0或者num大于表长时，跳出while循环，来到if语句，判断不合法
20 puts("num值非法！");
21 }
22 else
23 {
24 *value = p->data;
25 printf("找到第%d个元素的值 = %c\n", num, *value);
26 }
27 }
//时间复杂度0（n），n为表长
1 /*
2 3、删除结点
3 删除第i个元素，并用value返回值
4 */
5
6 void deleteList(LinkList L, int i, char *value)
7 {
8 LinkList p = L;//头脑一定要清晰！这里p应该指向头结点
9 LinkList temp;
10 int j = 0;//对应着头结点的序号0
11
12 /*while (p && j < i)
13 {
14 p = p->next;此时，p指向的是i元素位置，要删除i元素，需要知道i的前驱！
15 j++;
16 }*/
17
18 while (p->next && j < i - 1)//i - 1可以保证指向其前驱 ，j=0需要注意，删除是从1-n都可以
19 {
20 p = p->next;//指向i元素前驱（i-1）
21 j++;
22 }
23 //必须想到判断合法性
24 if (!(p->next) || j > i - 1)//同样判断i的下边界，和上边界
25 {
26 puts("i值不合法！");
27 }
28 else
29 {
30 //找到了前驱p
31 temp = p->next;//temp指针指向i元素
32 //p->next = p->next->next;等价于
33 p->next = temp->next;//链表删除结点的关键逻辑
34 *value = temp->data;
35 free(temp);//释放temp指向的结点的内存空间
36 temp = NULL;
37 puts("删除成功！");
38 }
39 }
时间复杂度，虽然没有移动任何元素，还是0（n），因为最坏时核心语句频度为n（表长）
为什么不是p？
//判断表为非空，因为不止一次删除操作！总会删空，则p还是指向的头结点！如果依然是while（p &&……），表空时，按道理函数不应该再执行核心语句，提前判断出错，但此时却还要执行循环体，循环结束才能到if（！p），而使用while(p->next && ……），表空就直接跳出循环，到if语句，提示错误。这是删除算法总是需要注意的细节，插入算法则是如果内存有限，或者是顺序的表，或者静态链表，那么总是要注意存储空间满足大小的问题
1 /*
2 4、插入结点
3 在第i个位置之前插入结点e，换句话说就是在第i-1个位置之后插入，类似前面的删除操作思想
4 */
5 void insertList(LinkList L, int i, char value)
6 {
7 LinkList p = L;
8 LinkList s;
9 int j = 0;
10 //和删除不同，插入操作不用注意表空的情况
11 while (p && j < i - 1)
12 {
13 p = p->next;
14 j++;
15 }
16
17 if (!p || j > i - 1)//i小于1或者大于表长+1不合法
18 {
19 puts("i不合法！");
20 }
21 else
22 {
23 //先分配结点存储空间
24 s = (LinkList)malloc(sizeof(Node));
25 //依次传入插入的元素内容和修改逻辑链接
26 s->data = value;
27 //链表插入算法的关键逻辑
28 s->next = p->next;
29 p->next = s;//顺序不可颠倒，原则是指针在修改前，先保留再修改，不能先修改再保留
30 puts("插入成功！");
31 }
32 }
插入算法时间复杂度分析：0(n)，最坏情况下频度是n
/插入和删除算法，还有一个思路，就是既然需要每次都找前驱，那么为什么不弄两个指针呢？一个指向当前位置，一个紧随其后指向前，个人其实感觉是脱裤子放屁……
1 //以删除为例
2 void deleteList(LinkList L, int i, char *value)
3 {
4 LinkList prePoint = L;//前驱指针初始化指向头结点
5 LinkList point = L->next;//当前指针初始化指向第一个结点
6 LinkList temp = NULL;
7 int j = 1;
8 //i要>0,且小于等于表长
9 while (point && j < i)//如果表非空，找到要删除的元素位置
10 {
11 point = point->next;
12 prePoint = prePoint->next;//分别顺次后移
13 j++;
14 }
15
16 if (!point || j > i)
17 {
18 puts("i不合法！");
19 }
20 else
21 {
22 temp = point;
23 prePoint->next = point->next;
24 *value = temp->data;
25 free(temp);
26 temp = NULL;
27 puts("删除成功！");
28 }
29 }
时间复杂度依然是O(n)
1 /*
2 5、头插法建立单链表（逆序建表）
3 从一个空结点开始，逐个把 n 个结点插入到当前链表的表头
4 */
5
6 //开始就空表，则肯定先分配结点（带头结点）
7 void createListByHead(LinkList *L, int n)
8 {
9 LinkList p = NULL;
10 int i = 0;
11 *L = (LinkList)malloc(sizeof(Node));//L指向头结点
12 (*L)->next = NULL;//空表建立
13 //头插法
14 for (i = 1; i <= n; i++)
15 {
16 p = (LinkList)malloc(sizeof(Node));//先创建要插入的结点
17 scanf("%c", &(p->data));//给结点数据域赋值 再次验证 -> 优先级高于取地址 &
18
19 while (getchar() != ‘\n‘)
20 {
21 continue;
22 }
23
24 p->next = (*L)->next;//再让插入的结点的next指针指向后继（链接的过程），注意后继不能为空（除去第一次插入）
25 //p->next = NULL;//错误
26 (*L)->next = p;//最后保证插入结点是第一个结点，把头结点和第一个结点链接起来。
27 }
28
29 printf("头插法建表成功\n");
30 }
时间复杂度：必然是O（n），插入了n个元素
链表和顺序表存储结构不同，动态,整个可用内存空间可以被多个链表共享，每个链表无需事先分配存储容量，由系统应要求自动申请。建立链表是动态的过程。
//如a b c d，依次头插法（头插 总是在第一个结点前插入，暨插入的结点总是作为第一个结点）到空链表里，那么完成之后是
//d c b a
下面是正序的尾插法，如图
1 /*
2 6、尾插法建立单链表（顺序建表）
3 //对 5 算法的改进
4 */
5 //头插法算法简单，但生成的链表结点次序和输入的顺序相反。有时不太方便。
6 //若希望二者次序一致，可采用尾插法建表。该方法是将新结点顺次的插入到当前链表的表尾上，为此必须增加一个尾指针tail，
7 //使其始终指向当前链表的尾结点。
8 void createListByTail(LinkList *L, int n)
9 {
10 LinkList tail = NULL;//尾指针
11 int i = 0;
12 LinkList p = NULL;//代表前驱
13 *L = (LinkList)malloc(sizeof(Node));
14 (*L)->next = NULL;
15 tail = *L;
16
17 for (i = 1; i <= n; i++)
18 {
19 p = (LinkList)malloc(sizeof(Node));
20 //_CRTIMP int __cdecl scanf(_In_z_ _Scanf_format_string_ const char * _Format, ...);返回int，传入的参数个数
21 /*如果被成功读入，返回值为参数个数
22 如果都未被成功读入，返回值为0
23 如果遇到错误或遇到end of file，返回值为EOF*/
24 scanf("%c", &(p->data));
25 //清空输入队列的剩余的所有字符
26 while (getchar() != ‘\n‘)
27 {
28 continue;
29 }
30 //尾插操作，后继总是空的
31 p->next = NULL;
32 //链接前驱
33 tail->next = p;//万万不能写成*L->next = p;
34 //保证尾指针tail总是指向最后一个结点
35 tail = p;
36 }
37
38 printf("尾插法建表成功！ \n");
39 }
这样操作，输入的序列和输出的序列是正序的，且时间复杂度为O（n）
1 /*
2 7、尾插法建立有序单链表（归并链表）
3 把两个有序（非递减）链表LA LB合并为一个新的有序（非递减）链表LC(空表)
4 要求：不需要额外申请结点空间来完成
5 */
6
7 //1、比较数据域，保证有序
8 //2、尾插法思想
9 //3、不需要额外申请结点空间来完成！
10 //使用现有的内存空间，完成操作，那么可以想到用LC的头指针去指向其中某个表的头结点，内存共享
11
12 void mergeListsByTail(LinkList LA, LinkList LB, LinkList LC)
13 {
14 //因为要比较数据大小，需要两个标记指针，分别初始化为标记AB的第一个结点
15 LinkList listA = LA->next;
16 LinkList listB = LB->next;
17 //还要不开辟内存，那么内存共享，需要把表C让其他表去表示
18 LinkList listC;//声明一个标记C的指针
19 LC = LA;//比如表A。C表的头指针指向A表的头结点，做自己的头结点
20 listC = LA;//C表的标记指针需要初始化，指向A的头结点，待命
21 //接下来比较AB表数据，标记指针会顺次后移，早晚有一个先指向末尾之后的NULL，故判断是哪一个表的
22 while (listA && listB)
23 {
24 //判断数据大小,非递减
25 if (listA->data <= listB->data)
26 {
27 //则A的结点插入到C表（尾插）,单链表不可使用头指针做遍历
28 listC->next = listA;//先把A的结点链到C表
29 listC = listA;//listC等价于尾指针
30 //A指针后移,继续循环比较
31 listA = listA->next;
32 }
33 else
34 {
35 //把B的结点插入到C（尾插）
36 listC->next = listB;
37 listC = listB;
38 listB = listB->next;
39 }//end of if
40 }//end of while
41 //循环结束，只需要把剩下的某个表的结点一次性链接到C表尾
42 if (listA)
43 {
44 //说明B空
45 listC->next = listA;
46 }
47
48 if (listB)
49 {
50 //A空
51 listC->next = listB;
52 }
53 //最后AB表比较之前一定有一个表都被遍历了（也就是链接到了C），剩下的结点比如属于某个表的，最后也都链接到C尾部
54 //那么，此时就还有一个结点，那就是B表的头结点！勿忘把B表头结点释放，这才是完全的两个归并为一个
55 free(LB);
56 LB = NULL;//杜绝野指针
57 }
算法时间复杂度，和头插法比较的话，还是O（n）,其实顺序表的有序归并也是这个时间复杂度O（A.length + B.length），但是链表的尾插法归并没有移动元素，只是解除和重建链接的操作，也没有额外开辟内存空间。空间复杂度不同。
1 /*
2 8、销毁单链表
3 */
4 void destoryLinkList(LinkList *L)
5 {
6 LinkList p = NULL;
7
8 while (*L)
9 {
10 p = (*L)->next;
11 free(*L);//free不能对指向NULL的指针使用多次！
12 *L = p;
13 //彻底搞掉指针本身，free（L）仅仅是销毁指针指向的内存，故还要连头结点一起干掉，不过while循环里隐形的包含了
14 }
15
16 *L = NULL;
17 puts("链表L已经销毁，不存在！");
18 }
函数内部有动态分配内存的情形，应该把参数设定为指向指针的指针，当然还有别的方法，我习惯而已。
记得说：值传递函数，是把实参的一个拷贝送到函数体，函数体修改的是那份传入的拷贝，不是函数跑到main里去给它修改。
且形参和传入的拷贝，还有函数体内的变量（栈中分配的内存），都是是代码块内的自动存储类型的变量，也就是局部变量，函数执行完毕，变量自动销毁，改变就不起作用。
指针形参可以改变实参，但是如果是针对函数内动态分配了内存的情况，把堆分配的内存地址赋给了指针参数，改变的是指针指向的内容，而指针变量（形参）本身的内存地址没有改变，故根本句不会成功修改实参。
指向指针的指针，存放的是指向实参内存地址A的指针的地址B，修改B地址，改变了B指向的内容，而B指向的内容恰恰就是一级指针A本身，一级指针A的修改，使得实参被改变，对实参（指针变量C），需要取出指针C自己的的地址，传入函数。达到间接修改实参的目的。
1 /*
2 9、求表长，长度保存在头结点
3 */
4 void getLength(LinkList L)
5 {
6 int length = 0;
7 LinkList p = NULL;
8
9 if (L)
10 {
11 p = L->next;
12
13 while (p)
14 {
15 p = p->next;
16 length++;
17 }
18
19 L->data = length;
20 printf("%d\n", L->data);
21 }
22 else
23 {
24 puts("表已经销毁！无法计算长度了……");
25 }
26 }
1 /*
2 10、遍历链表
3 */
4 void traversalList(LinkList L)
5 {
6 int i = 0;
7 int length = 0;
8 LinkList p = L->next;
9 length = L->data;//遍历之前，务必先求表长！
10 puts("遍历之前，务必先求表长！");
11
12 for (; i < length; i++)
13 {
14 putchar(p->data);
15 p = p->next;
16 }
17 putchar(‘\n‘);
18 }
测试
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <assert.h>
4 #include "ADT.h"
5
6 int main(void)
7 {
8 LinkList L = NULL;//完全的空表，连头结点都没有
9 LinkList LTwo = NULL;
10 LinkList val = NULL;
11 int i = 0;
12 char value = ‘0‘;
13
14 puts("请输入5个字符变量（一行一个）：");
15 puts("使用尾插法建立单链表L，5个结点，一个头结点");
16 //输入 12345
17 createListByTail(&L, 5);//尾插法建表
18
19 //12345正确的存入到了5个结点里，尾插法创建了一个单链表L
20
21 //先求长度
22 puts("L长度为");
23 getLength(L);
24
25 //遍历 12345
26 puts("遍历这个链表结点元素");
27 traversalList(L);
28
29 //用完必须销毁
30 puts("把链表L销毁，L = NULL;");
31 destoryLinkList(&L);
32
33 //头插法 abcde
34 //void createListByHead(<wo, 5);//报错;语法错误 : 缺少“;”(在“类型”的前面)
35 puts("使用头插法建立新的单链表LTwo，5个结点，一个头结点");
36 createListByHead(<wo, 5);
37
38 //求长度
39 getLength(LTwo);
40
41 //遍历 edcba
42 puts("遍历表中结点元素");
43 traversalList(LTwo);
44
45 //按值查找
46 puts("查找LTwo表的结点数据 = ‘2’的结点");
47 val = getElemByValue(LTwo, ‘2‘);
48
49 if (val)
50 {
51 printf("找到了val，地址 = %p \n", &val);
52 }
53
54 puts("‘2’在表 LTwo 里没找到！");
55
56 //插入结点
57 puts("在位置 1 之后插入一个结点，里面数据是 ‘p’");
58 insertList(LTwo, 1, ‘p‘);
59
60 //遍历 pedcba
61 puts("开始遍历表LTwo");
62 traversalList(LTwo);
63
64 //按序查找
65 puts("查找位置=2的结点，并打印出它的数据内容");
66 getElemByNum(LTwo, 2, &value);
67
68
69 //删除结点
70 puts("删除位置 1 的结点，并打印出删除结点的数据");
71 deleteList(LTwo, 1, &value);
72 printf("%c\n", value);
73
74 //遍历 pedcba
75 puts("再次遍历链表LTwo");
76 traversalList(LTwo);
77
78 //求链表长度，把长度保存的头结点
79 puts("计算链表长度，并把长度保存到了LTwo的头结点");
80 getLength(LTwo);
81 printf("%d\n", LTwo->data);
82
83 //必须有销毁
84 puts("动态存储的结构用完一定要销毁");
85 destoryLinkList(<wo);
86
87 //此时销毁的表长规定是0
88 puts("销毁之后，链表长度：");
89 getLength(LTwo);
90
91 system("pause");
92 return 0;
93 }
scanf函数的特点是接受单词，而不是字符串，字符串一般是gets函数，单个字符接收是getchar函数，因为scanf函数遇到空白字符（tab，空格，回车，制表符等）就不再读取输入，那字符串怎么能方便输入？
但是输入队列里如果还有字符，那么会留到缓存内，需要在定义里使用getchar函数来消除回车带来的影响。
时间： 2024-10-17 15:36:36