• 第三部分—数据结构与算法基础_2. 线性表

    数据结构大致包含以下几种存储结构：

    • 线性表：还可细分为顺序表、链表、栈、队列。
    • 树结构：包括普通树、二叉树、线索二叉树。
    • 图储存结构。

    2.1线性表基本概念

    线性结构是一种最简单且常用的数据结构。线性结构的基本特点是节点之间满足线性关系。本章讨论的动态数组、链表、栈、队列都属于线性结构。他们的共同之处，是节点中有且只有一个开始节点和终端节点。按这种关系，可以把它们的所有节点排列成一个线性序列。但是，他们分别属于几种不同的抽象数据类型实现，它们之间的区别，主要就是操作的不同。

    线性表是零个或者多个数据元素的有限序列，数据元素之间是有顺序的，数据元素个数是有限的，数据元素的类型必须相同

    2.2线性表的顺序存储

    通常线性表可以采用顺序存储和链式存储。这节课我们主要探讨顺序存储结构以及对应的运算算法的实现。

    采用顺序存储是表示线性表最简单的方法，具体做法是：将线性表中的元素一个接一个的存储在一块连续的存储区域中，这种顺序表示的线性表也成为顺序表。

    2.2.1线性表顺序存储(顺序表)的设计与实现

    操作要点:

    1. 插入元素算法判断线性表是否合法
      1. 判断插入位置是否合法
      2. 判断空间是否满足
      3. 把最后一个元素到插入位置的元素后移一个位置
      4. 将新元素插入
      5. 线性表长度加1
    2. 获取元素操作
      1. 判断线性表是否合法
      2. 判断位置是否合法
      3. 直接通过数组下标的方式获取元素
    3. 删除元素算法
      1. 判断线性表是否合法
      2. 判断删除位置是否合法
      3. 将元素取出
      4. 将删除位置后的元素分别向前移动一个位置
      5. 线性表长度减

    1.元素的插入

    ​

    2.元素的删除

    ​

    2.2.2优点和缺点

    • 优点：
    1. 无需为线性表中的逻辑关系增加额外的空间。
    2. 可以快速的获取表中合法位置的元素。
    • 缺点：
    1. 插入和删除操作需要移动大量元素。

    2.2.3 顺序表的代码实现

    1.创建三个文件

    2.代码实现

    1. //Sequence_List_Head.h部分
    2.  
    3. #pragma once
    4. #define _CRT_SECURE_NO_WARNINGS
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14.  
    15. //1.定义结构体
    16. struct SequenceList
    17. {
    18. 	void** pSeqList; 
    19. 	int Capacity;
    20. 	int Size;
    21. };
    22.  
    23.  
    24. //2.初始化顺序表函数声明
    25. struct SequenceList* InitSequenceList(int capacity);
    26.  
    27.  
    28. //3.插入元素函数声明
    29. void InsertSequenceList(struct SequenceList* seqlist, int pos, void* data);
    30.  
    31.  
    32. //4.遍历顺序表函数声明
    33. void DisplaySequenceList(struct SequenceList* seqlist, void(*Print)(void*));
    34.  
    35.  
    36. //5.删除元素函数声明（按位置删除）
    37. void DeleteSequenceList_pos(struct SequenceList* seqlist, int pos);
    38.  
    39.  
    40. //6.删除元素函数声明（按值删除）
    41. void DeleteSequenceList_value(struct SequenceList* seqlist, void* data, int(*Compare)(void*, void*));
    42.  
    43.  
    44. //7.销毁数组函数声明
    45. void DestroySequenceList(struct SequenceList* seqlist);
    46.  
    47.  
    48.  
    49.  
    50.  
    51.  
    52.  
    53.  
    54.  
    55.  
    56.  
    57.  
    58.  
    59.  
    60.  
    61.  
    62.  
    63.  
    64.  
    65. //Sequence_List_Function.c部分
    66.  
    67. #define _CRT_SECURE_NO_WARNINGS
    68. #include 
    69. #include 
    70. #include 
    71. #include 
    72. #include 
    73. #include 
    74. #include 
    75. #include 
    76. #include 
    77. #include "Sequence_List_Head.h"
    78.  
    79. //2.初始化顺序表函数实现
    80. struct SequenceList* InitSequenceList(int capacity)
    81. {
    82. 	if (capacity <= 0)
    83. 	{
    84. 		return NULL;
    85. 	}
    86.  
    87. 	//申请空间
    88. 	struct SequenceList* seqlist = malloc(sizeof(struct SequenceList));
    89. 	if (seqlist == NULL)
    90. 	{
    91. 		return NULL;
    92. 	}
    93.  
    94. 	//初始化空间
    95. 	seqlist->pSeqList = malloc(sizeof(void*) * capacity);
    96. 	seqlist->Capacity = capacity;
    97. 	seqlist->Size = 0;
    98.  
    99. 	return seqlist;
    100. }
    101.  
    102.  
    103.  
    104.  
    105. //3.插入元素函数实现
    106. void InsertSequenceList(struct SequenceList* seqlist, int pos, void* data)
    107. {
    108. 	if (seqlist == NULL)
    109. 	{
    110. 		return;
    111. 	}
    112. 	if (data == NULL)
    113. 	{
    114. 		return;
    115. 	}
    116.  
    117. 	if (pos<0 || pos>seqlist->Size)
    118. 	{
    119. 		pos = seqlist->Size;
    120. 	}
    121.  
    122. 	if (seqlist->Size == seqlist->Capacity)
    123. 	{
    124. 		int newCapacity = 2 * (seqlist->Capacity);
    125. 		void** newpSeqList = realloc(seqlist->pSeqList, sizeof(void*) * newCapacity);
    126. 		if (newpSeqList == NULL)
    127. 		{
    128. 			return;
    129. 		}
    130. 		else
    131. 		{
    132. 			seqlist->pSeqList = newpSeqList;
    133. 			seqlist->Capacity = newCapacity;
    134. 		}
    135. 	}
    136.  
    137. 	for (int i = seqlist->Size - 1; i >= pos; i--)
    138. 	{
    139. 		//数据向后移动
    140. 		seqlist->pSeqList[i + 1] = seqlist->pSeqList[i];
    141. 	}
    142. 	seqlist->pSeqList[pos] = data;
    143. 	seqlist->Size++;
    144. }
    145.  
    146.  
    147.  
    148. //4.遍历顺序表函数实现
    149. void DisplaySequenceList(struct SequenceList* seqlist, void(*Print)(void*))
    150. {
    151. 	if (seqlist == NULL)
    152. 	{
    153. 		return;
    154. 	}
    155. 	if (Print == NULL)
    156. 	{
    157. 		return;
    158. 	}
    159. 	for (int i = 0; i < seqlist->Size; i++)
    160. 	{
    161. 		Print(seqlist->pSeqList[i]);
    162. 	}
    163. }
    164.  
    165.  
    166.  
    167. //5.删除元素函数实现（按位置删除）
    168. void DeleteSequenceList_pos(struct SequenceList* seqlist, int pos)
    169. {
    170. 	if (seqlist == NULL)
    171. 	{
    172. 		return;
    173. 	}
    174. 	if (pos<0 || pos>seqlist->Size - 1)
    175. 	{
    176. 		return;
    177. 	}
    178. 	//数据前移
    179. 	for (int i = pos; i < seqlist->Size - 1; i++)
    180. 	{
    181. 		seqlist->pSeqList[i] = seqlist->pSeqList[i + 1];
    182. 	}
    183. 	seqlist->Size--;
    184. }
    185.  
    186.  
    187.  
    188. //6.删除元素函数实现（按值删除）
    189. void DeleteSequenceList_value(struct SequenceList* seqlist, void* data, int(*Compare)(void*, void*))
    190. {
    191. 	if (seqlist == NULL)
    192. 	{
    193. 		return;
    194. 	}
    195. 	if (data == NULL)
    196. 	{
    197. 		return;
    198. 	}
    199.  
    200. 	for (int i = 0; i < seqlist->Size; i++)
    201. 	{
    202. 		if (Compare(seqlist->pSeqList[i], data))
    203. 		{
    204. 			DeleteSequenceList_pos(seqlist, i);
    205. 			break;
    206. 		}
    207. 	}
    208. }
    209.  
    210.  
    211.  
    212. //7.销毁数组函数实现
    213. void DestroySequenceList(struct SequenceList* seqlist)
    214. {
    215. 	if (seqlist == NULL)
    216. 	{
    217. 		return;
    218. 	}
    219. 	if (seqlist->pSeqList != NULL)
    220. 	{
    221. 		free(seqlist->pSeqList);
    222. 		seqlist->pSeqList = NULL;
    223. 	}
    224. 	
    225. 	free(seqlist);
    226. 	seqlist = NULL;
    227. }
    228.  
    229.  
    230.  
    231.  
    232.  
    233.  
    234.  
    235.  
    236.  
    237.  
    238.  
    239.  
    240.  
    241.  
    242.  
    243. //Sequence_List_Main.c部分
    244.  
    245. #define _CRT_SECURE_NO_WARNINGS
    246. #include 
    247. #include 
    248. #include 
    249. #include 
    250. #include 
    251. #include 
    252. #include 
    253. #include 
    254. #include 
    255. #include "Sequence_List_Head.h"
    256.  
    257. //测试代码
    258. //1.自定义数据类型
    259. struct Person
    260. {
    261. 	char name[64];
    262. 	int age;
    263. };
    264.  
    265.  
    266. //2.打印函数
    267. void myPrint(void* data)
    268. {
    269. 	struct Person* p = data;
    270. 	printf("姓名：%s 年龄：%d\n", p->name, p->age);
    271. }
    272.  
    273.  
    274. //3.对比函数
    275. int myCompare(void* data1, void* data2)
    276. {
    277. 	struct Person* p1 = data1;
    278. 	struct Person* p2 = data2;
    279. 	return (strcmp(p1->name, p2->name) == 0) && (p1->age == p2->age);
    280. }
    281.  
    282.  
    283. int main()
    284. {
    285. 	//初始化动态数组
    286. 	struct SequenceList* seqlist = InitSequenceList(5);
    287.  
    288. 	//准备数据
    289. 	struct Person p1 = { "亚瑟", 18 };
    290. 	struct Person p2 = { "妲己", 20 };
    291. 	struct Person p3 = { "安琪拉", 19 };
    292. 	struct Person p4 = { "凯", 21 };
    293. 	struct Person p5 = { "孙悟空", 999 };
    294. 	struct Person p6 = { "李白", 999 };
    295. 	printf("插入数据前： 容量：%d  大小：%d\n", seqlist->Size, seqlist->Size);
    296. 	//插入数据
    297. 	InsertSequenceList(seqlist, 0, &p1);
    298. 	InsertSequenceList(seqlist, 0, &p2);
    299. 	InsertSequenceList(seqlist, 1, &p3);
    300. 	InsertSequenceList(seqlist, 0, &p4);
    301. 	InsertSequenceList(seqlist, -1, &p5);
    302. 	InsertSequenceList(seqlist, 2, &p6);
    303. 	//遍历数据
    304. 	DisplaySequenceList(seqlist, myPrint);
    305. 	printf("插入数据后： 容量：%d  大小：%d\n", seqlist->Capacity, seqlist->Size);
    306.  
    307. 	//按位置删除
    308. 	DeleteSequenceList_pos(seqlist, 2);
    309. 	printf("---------------------\n");
    310. 	DisplaySequenceList(seqlist, myPrint);
    311. 	printf("删除数据后： 容量：%d  大小：%d\n", seqlist->Capacity, seqlist->Size);
    312.  
    313. 	//按值删除
    314. 	struct Person  p = { "亚瑟", 18 };
    315. 	DeleteSequenceList_value(seqlist, &p, myCompare);
    316. 	printf("---------------------\n");
    317. 	DisplaySequenceList(seqlist, myPrint);
    318. 	printf("删除数据后： 容量：%d  大小：%d\n", seqlist->Capacity, seqlist->Size);
    319.  
    320.  
    321. 	//销毁数组
    322. 	DestroySequenceList(seqlist);
    323. 	return 0;
    324. }

    输出结果

    1. 插入数据前： 容量：0  大小：0
    2. 姓名：凯 年龄：21
    3. 姓名：妲己 年龄：20
    4. 姓名：李白 年龄：999
    5. 姓名：安琪拉 年龄：19
    6. 姓名：亚瑟 年龄：18
    7. 姓名：孙悟空 年龄：999
    8. 插入数据后： 容量：10  大小：6
    9. ---------------------
    10. 姓名：凯 年龄：21
    11. 姓名：妲己 年龄：20
    12. 姓名：安琪拉 年龄：19
    13. 姓名：亚瑟 年龄：18
    14. 姓名：孙悟空 年龄：999
    15. 删除数据后： 容量：10  大小：5
    16. ---------------------
    17. 姓名：凯 年龄：21
    18. 姓名：妲己 年龄：20
    19. 姓名：安琪拉 年龄：19
    20. 姓名：孙悟空 年龄：999
    21. 删除数据后： 容量：10  大小：4

    2.3线性表的链式存储(单向链表)

    前面我们写的线性表的顺序存储(顺序表)的案例，最大的缺点是插入和删除时需要移动大量元素，这显然需要耗费时间，能不能想办法解决呢？链表。

    链表为了表示每个数据元素与其直接后继元素之间的逻辑关系，每个元素除了存储本身的信息外，还需要存储指示其直接后继的信息。

    1.单链表

    （1）线性表的链式存储结构中，每个节点中只包含一个指针域，这样的链表叫单链表。

    （2）通过每个节点的指针域将线性表的数据元素按其逻辑次序链接在一起（如图）。

    2.概念解释：

    （1）表头结点

    链表中的第一个结点，包含指向第一个数据元素的指针以及链表自身的一些信息

    （2）数据结点

    链表中代表数据元素的结点，包含指向下一个数据元素的指针和数据元素的信息

    （3）尾结点

    链表中的最后一个数据结点，其下一元素指针为空，表示无后继。

    2.3.1线性表的链式存储(单链表)的设计与实现

    • 插入操作

    node->next = current->next;

    current->next = node;

    • 删除操作

     current->next = ret->next;

    2.3.2优点和缺点

    • 优点：
    1. 无需一次性定制链表的容量
    2. 插入和删除操作无需移动数据元素
    • 缺点：
    1. 数据元素必须保存后继元素的位置信息
    2. 获取指定数据的元素操作需要顺序访问之前的元素

    2.3.3单链表的代码实现

    1. 创建三个文件

    2.代码部分 

    1. //1.Single_Linked_List_Head.h 部分
    2.  
    3. #pragma once
    4. #define _CRT_SECURE_NO_WARNINGS
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. typedef void* pSingleLinkedList;
    15.  
    16. //1.定义节点结构体
    17. struct LinkNode
    18. {
    19. 	//数据域;
    20. 	void* data;
    21. 	//指针域
    22. 	struct LinkNode* next;
    23. };
    24.  
    25.  
    26. //2.链表结构体
    27. struct SingleLinkedList
    28. {
    29. 	//头节点
    30. 	struct LinkNode Header;
    31. 	//链表长度
    32. 	int Size;
    33. };
    34.  
    35.  
    36.  
    37. //3.初始化链表函数声明
    38. pSingleLinkedList Init_LinkList();
    39.  
    40.  
    41.  
    42. //4.插入链表函数声明
    43. void InsertLinkList(pSingleLinkedList TmpLinkList, int pos, void* data);
    44.  
    45.  
    46.  
    47. //5.遍历链表函数声明
    48. void DisplaySingleLinkedList(pSingleLinkedList TmpLinkList, void(*Print)(void*));
    49.  
    50.  
    51.  
    52. //6.按位置删除链表函数声明
    53. void DeleteSingleLinkedListBypos(pSingleLinkedList TmpLinkList, int pos);
    54.  
    55.  
    56.  
    57. //7.按值删除链表函数声明
    58. void DeleteSingleLinkedListByvalue(pSingleLinkedList TmpLinkList, void* data, int(*Compare)(void*, void*));
    59.  
    60.  
    61.  
    62. //8.返回链表长度函数声明
    63. int size_LinkList(pSingleLinkedList TmpLinkList);
    64.  
    65.  
    66.  
    67. //9.清空链表函数声明
    68. void ClearLinkList(pSingleLinkedList TmpLinkList);
    69.  
    70.  
    71.  
    72. //10.销毁链表函数声明
    73. void DestroyLinkList(pSingleLinkedList TmpLinkList);
    74.  
    75.  
    76.  
    77.  
    78.  
    79.  
    80.  
    81.  
    82.  
    83.  
    84.  
    85.  
    86.  
    87.  
    88.  
    89.  
    90.  
    91.  
    92.  
    93.  
    94.  
    95.  
    96.  
    97.  
    98.  
    99.  
    100.  
    101.  
    102.  
    103.  
    104.  
    105. //2.Single_Linked_List_Function.c部分
    106.  
    107. #pragma once
    108. #define _CRT_SECURE_NO_WARNINGS
    109. #include 
    110. #include 
    111. #include 
    112. #include 
    113. #include 
    114. #include 
    115. #include 
    116. #include 
    117. #include 
    118. #include "Single_Linked_List_Head.h"
    119.  
    120.  
    121. //3.初始化链表函数实现
    122. pSingleLinkedList Init_LinkList()
    123. {
    124. 	struct SingleLinkedList* MyLinkList = malloc(sizeof(struct SingleLinkedList));
    125. 	if (MyLinkList == NULL)
    126. 	{
    127. 		return NULL;
    128. 	}
    129.  
    130. 	MyLinkList->Header.data = NULL;
    131. 	MyLinkList->Header.next = NULL;
    132. 	MyLinkList->Size = 0;
    133. 	return MyLinkList;
    134. }
    135.  
    136.  
    137.  
    138. //4.插入链表函数声明
    139. void InsertLinkList(pSingleLinkedList TmpLinkList, int pos, void* data)
    140. {
    141. 	if (TmpLinkList == NULL)
    142. 	{
    143. 		return ;
    144. 	}
    145. 	if (data == NULL)
    146. 	{
    147. 		return ;
    148. 	}
    149. 	//将TmpLinkList还原成struct SingleLinkedList数据类型
    150. 	struct SingleLinkedList* myList = TmpLinkList;
    151. 	if (pos<0 || pos>myList->Size)
    152. 	{
    153. 		//无效位置就做强制尾插
    154. 		pos = myList->Size;
    155. 	}
    156. 	//找到插入节点的位置
    157. 	struct LinkNode* pCurrent = &myList->Header;
    158. 	for (int i = 0; i < pos; i++)
    159. 	{
    160. 		pCurrent = pCurrent->next;
    161. 	}
    162.  
    163. 	//创建新节点
    164. 	struct LinkNode* newNode = malloc(sizeof(struct LinkNode));
    165. 	if (newNode != NULL)
    166. 	{
    167. 		newNode->data = data;
    168. 		newNode->next = NULL;
    169. 	}
    170. 	else
    171. 	{
    172. 		return;
    173. 	}
    174. 	
    175. 	//建立节点关系
    176. 	newNode->next = pCurrent->next;
    177. 	pCurrent->next = newNode;
    178.  
    179. 	//更新链表长度
    180. 	myList->Size++;
    181. }
    182.  
    183.  
    184.  
    185. //5.遍历链表函数实现
    186. void DisplaySingleLinkedList(pSingleLinkedList TmpLinkList, void(*Print)(void*))
    187. {
    188. 	if (TmpLinkList == NULL)
    189. 	{
    190. 		return;
    191. 	}
    192. 	if (Print == NULL)
    193. 	{
    194. 		return;
    195. 	}
    196.  
    197. 	struct SingleLinkedList* mylist = TmpLinkList;
    198. 	struct LinkNode* pCurrent = mylist->Header.next;
    199. 	for (int i = 0; i < mylist->Size; i++)
    200. 	{
    201. 		Print(pCurrent->data);
    202. 		pCurrent = pCurrent->next;
    203. 	}
    204. }
    205.  
    206.  
    207.  
    208. //6.按位置删除链表函数声明
    209. void DeleteSingleLinkedListBypos(pSingleLinkedList TmpLinkList, int pos)
    210. {
    211. 	if (TmpLinkList == NULL)
    212. 	{
    213. 		return;
    214. 	}
    215.  
    216. 	struct SingleLinkedList* mylist = TmpLinkList;
    217. 	if (pos<0 || pos>mylist->Size - 1)
    218. 	{
    219. 		return;
    220. 	}
    221.  
    222. 	//找到待删除节点的前节点
    223. 	struct LinkNode* pCurrent = &mylist->Header;
    224. 	for (int i = 0; i < pos; i++)
    225. 	{
    226. 		pCurrent = pCurrent->next;
    227. 	}
    228. 	//记录待删除的节点
    229. 	struct LinkNode* pDeleteNode = pCurrent->next;
    230. 	//重新建立节点关系
    231. 	pCurrent->next = pDeleteNode->next;
    232.  
    233. 	free(pDeleteNode);
    234. 	pDeleteNode = NULL;
    235.  
    236. 	//更新链表长度
    237. 	mylist->Size--;
    238. }
    239.  
    240.  
    241.  
    242.  
    243. //7.按值删除链表函数实现
    244. void DeleteSingleLinkedListByvalue(pSingleLinkedList TmpLinkList, void* data, int(*Compare)(void*, void*))
    245. {
    246. 	if (TmpLinkList == NULL)
    247. 	{
    248. 		return;
    249. 	}
    250. 	if (data == NULL)
    251. 	{
    252. 		return;
    253. 	}
    254.  
    255. 	struct SingleLinkedList* mylist = TmpLinkList;
    256. 	//创建两个辅助指针
    257. 	struct LinkNode* pPrevNode = &mylist->Header;
    258. 	struct LinkNode* pCurrent = pPrevNode->next;
    259.  
    260. 	for (int i = 0; i < mylist->Size; i++)
    261. 	{
    262. 		if (Compare(pCurrent->data, data))
    263. 		{
    264. 			pPrevNode->next = pCurrent->next;
    265. 			free(pCurrent);
    266. 			pCurrent = NULL;
    267. 			mylist->Size--;
    268. 			break;
    269. 		}
    270. 		pPrevNode = pCurrent;
    271. 		pCurrent = pCurrent->next;
    272. 	}
    273. }
    274.  
    275.  
    276.  
    277. //8.返回链表长度函数实现
    278. int size_LinkList(pSingleLinkedList TmpLinkList)
    279. {
    280. 	if (TmpLinkList == NULL)
    281. 	{
    282. 		return -1;
    283. 	}
    284. 	struct SingleLinkedList* mylist = TmpLinkList;
    285. 	return mylist->Size;
    286. }
    287.  
    288.  
    289.  
    290. //9.清空链表函数实现
    291. void ClearLinkList(pSingleLinkedList TmpLinkList)
    292. {
    293. 	if (TmpLinkList == NULL)
    294. 	{
    295. 		return;
    296. 	}
    297.  
    298. 	struct SingleLinkedList* mylist = TmpLinkList;
    299. 	struct LinkNode* pCurrent = mylist->Header.next;
    300. 	struct LinkNode* pNextNode = pCurrent->next;
    301. 	for (int i = 0; i < mylist->Size; i++)
    302. 	{
    303. 		pNextNode = pCurrent->next;
    304. 		free(pCurrent);
    305. 		pCurrent = pNextNode;
    306. 	}
    307. 	mylist->Header.next = NULL;
    308. 	mylist->Size = 0;
    309. }
    310.  
    311.  
    312.  
    313. //10.销毁链表函数声明
    314. void DestroyLinkList(pSingleLinkedList TmpLinkList)
    315. {
    316. 	if (TmpLinkList == NULL)
    317. 	{
    318. 		return;
    319. 	}
    320. 	ClearLinkList(TmpLinkList);
    321. 	free(TmpLinkList);
    322. 	TmpLinkList = NULL;
    323. }
    324.  
    325.  
    326.  
    327.  
    328.  
    329.  
    330.  
    331.  
    332.  
    333.  
    334.  
    335.  
    336.  
    337.  
    338.  
    339.  
    340.  
    341.  
    342.  
    343.  
    344.  
    345.  
    346.  
    347.  
    348.  
    349.  
    350.  
    351. //3.Single_Linked_List_Main.c部分
    352.  
    353. #pragma once
    354. #define _CRT_SECURE_NO_WARNINGS
    355. #include 
    356. #include 
    357. #include 
    358. #include 
    359. #include 
    360. #include 
    361. #include 
    362. #include 
    363. #include 
    364. #include "Single_Linked_List_Head.h"
    365.  
    366.  
    367. //测试链表
    368.  
    369. //1.定义数据结构体
    370. struct Person
    371. {
    372. 	char name[64];
    373. 	int age;
    374. };
    375.  
    376.  
    377. //2.打印函数实现
    378. void Print(void* data)
    379. {
    380. 	struct Person* p = data;
    381. 	printf("姓名：%s 年龄：%d\n", p->name, p->age);
    382. }
    383.  
    384.  
    385. //3.比较函数实现
    386. int Compare(void* data1, void* data2)
    387. {
    388. 	struct Person* p1 = data1;
    389. 	struct Person* p2 = data2;
    390. 	return (strcmp(p1->name, p2->name) == 0) && (p1->age == p2->age);
    391. }
    392.  
    393.  
    394.  
    395. int main() 
    396. {
    397. 	//准备数据
    398. 	struct Person p1 = { "亚瑟", 18 };
    399. 	struct Person p2 = { "妲己", 20 };
    400. 	struct Person p3 = { "安琪拉", 19 };
    401. 	struct Person p4 = { "凯", 21 };
    402. 	struct Person p5 = { "孙悟空", 999 };
    403. 	struct Person p6 = { "李白", 999 };
    404.  
    405. 	//初始化链表
    406. 	pSingleLinkedList mylist = Init_LinkList();
    407. 	printf("链表长度为：%d\n", size_LinkList(mylist));
    408.  
    409. 	//插入数据
    410. 	InsertLinkList(mylist, 0, &p1);
    411. 	InsertLinkList(mylist, 0, &p2);
    412. 	InsertLinkList(mylist, -1, &p3);
    413. 	InsertLinkList(mylist, 0, &p4);
    414. 	InsertLinkList(mylist, 1, &p5);
    415. 	InsertLinkList(mylist, 0, &p6);
    416.  
    417. 	//遍历
    418. 	DisplaySingleLinkedList(mylist, Print);
    419. 	printf("链表长度为：%d\n", size_LinkList(mylist));
    420.  
    421. 	//按位置删除 
    422. 	DeleteSingleLinkedListBypos(mylist, 4);
    423. 	printf("------------------\n");
    424. 	DisplaySingleLinkedList(mylist, Print);
    425. 	printf("链表长度为：%d\n", size_LinkList(mylist));
    426.  
    427. 	//按值删除
    428. 	struct Person p = { "孙悟空", 999 };
    429. 	DeleteSingleLinkedListByvalue(mylist, &p, Compare);
    430. 	printf("------------------\n");
    431. 	DisplaySingleLinkedList(mylist, Print);
    432. 	printf("链表长度为：%d\n", size_LinkList(mylist));
    433.  
    434. 	//返回链表长度
    435. 	printf("链表长度为：%d\n", size_LinkList(mylist));
    436.  
    437. 	//销毁
    438. 	DestroyLinkList(mylist);
    439. 	mylist = NULL;
    440. 	return 0;
    441. }

    输出结果

    1. 链表长度为：0
    2. 姓名：李白 年龄：999
    3. 姓名：凯 年龄：21
    4. 姓名：孙悟空 年龄：999
    5. 姓名：妲己 年龄：20
    6. 姓名：亚瑟 年龄：18
    7. 姓名：安琪拉 年龄：19
    8. 链表长度为：6
    9. ------------------
    10. 姓名：李白 年龄：999
    11. 姓名：凯 年龄：21
    12. 姓名：孙悟空 年龄：999
    13. 姓名：妲己 年龄：20
    14. 姓名：安琪拉 年龄：19
    15. 链表长度为：5
    16. ------------------
    17. 姓名：李白 年龄：999
    18. 姓名：凯 年龄：21
    19. 姓名：妲己 年龄：20
    20. 姓名：安琪拉 年龄：19
    21. 链表长度为：4
    22. 链表长度为：4

    2.3.4单链表的代码实现（企业版）

    1.创建三个文件

    2.代码部分

    1. //1.Single_Linked_List_Enterprise_Edition_Head.h部分
    2.  
    3. #pragma once
    4. #define _CRT_SECURE_NO_WARNINGS
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. typedef void* pLinkList;
    15.  
    16. //1.定义节点结构体
    17. struct LinkListNode
    18. {
    19. 	//只维护指针域
    20. 	struct LinkNode* next;
    21. };
    22.  
    23.  
    24.  
    25. //2.定义链表结构体
    26. struct LinkList
    27. {
    28. 	struct LinkListNode pHeader;
    29. 	int _size;
    30. };
    31.  
    32.  
    33.  
    34. //3.初始化链表函数声明
    35. pLinkList InitLinkList();
    36.  
    37.  
    38.  
    39. //4.插入链表函数声明
    40. void InsertLinkList(pLinkList List, int pos, void* data);
    41.  
    42.  
    43.  
    44. //5.遍历链表函数声明
    45. void DisplayLinkList(pLinkList List, void(*Print)(void*));
    46.  
    47.  
    48.  
    49. //6.按位置删除节点函数声明
    50. void DeleteLinkListNode(pLinkList List, int pos);
    51.  
    52.  
    53.  
    54. //7.销毁链表函数声明
    55. void DestroyLinkList(pLinkList List);
    56.  
    57.  
    58.  
    59.  
    60.  
    61.  
    62.  
    63.  
    64.  
    65.  
    66.  
    67.  
    68.  
    69.  
    70.  
    71.  
    72.  
    73.  
    74.  
    75.  
    76.  
    77.  
    78.  
    79.  
    80.  
    81.  
    82.  
    83.  
    84.  
    85.  
    86.  
    87. //2.Single_Linked_List_Enterprise_Edition_Function.c部分
    88. #pragma once
    89. #define _CRT_SECURE_NO_WARNINGS
    90. #include 
    91. #include 
    92. #include 
    93. #include 
    94. #include 
    95. #include 
    96. #include 
    97. #include 
    98. #include 
    99. #include "Single_Linked_List_Enterprise_Edition_Head.h"
    100.  
    101.  
    102. //3.初始化链表函数实现
    103. pLinkList InitLinkList()
    104. {
    105. 	struct LinkList* myList = malloc(sizeof(struct LinkList));
    106. 	if (myList == NULL)
    107. 	{
    108. 		return NULL;
    109. 	}
    110.  
    111. 	myList->pHeader.next = NULL;
    112. 	myList->_size = 0;
    113. 	return myList;
    114. }
    115.  
    116.  
    117.  
    118. //4.插入链表函数声明
    119. void InsertLinkList(pLinkList List, int pos, void* data)
    120. {
    121. 	if (List == NULL)
    122. 	{
    123. 		return;
    124. 	}
    125. 	if (data == NULL)
    126. 	{
    127. 		return;
    128. 	}
    129.  
    130. 	struct LinkList* myList = List;
    131. 	if (pos<0 || pos>myList->_size - 1)
    132. 	{
    133. 		//无效位置进行尾插
    134. 		pos = myList->_size;
    135. 	}
    136.  
    137. 	//用户数据前4个字节由我们来使用
    138. 	struct LinkListNode* myNode = data;
    139.  
    140. 	//找插入节点的前驱节点
    141. 	struct LinkListNode* pCurrent = &myList->pHeader;
    142. 	for (int i = 0; i < pos - 1; i++)
    143. 	{
    144. 		pCurrent = pCurrent->next;
    145. 	}
    146.  
    147. 	//更改指针指向
    148. 	myNode->next = pCurrent->next;
    149. 	pCurrent->next = myNode;
    150.  
    151. 	//更新链表长度
    152. 	myList->_size++;
    153. }
    154.  
    155.  
    156.  
    157. //5.遍历链表函数实现
    158. void DisplayLinkList(pLinkList List, void(*Print)(void*))
    159. {
    160. 	if (List == NULL)
    161. 	{
    162. 		return;
    163. 	}
    164. 	struct LinkList* myList = List;
    165. 	struct LinkListNode* myNode = myList->pHeader.next;
    166.  
    167. 	for (int i = 0; i < myList->_size; i++)
    168. 	{
    169. 		Print(myNode);
    170. 		myNode = myNode->next;
    171. 	}
    172. }
    173.  
    174.  
    175.  
    176. //6.按位置删除节点函数实现
    177. void DeleteLinkListNode(pLinkList List, int pos)
    178. {
    179. 	if (List == NULL)
    180. 	{
    181. 		return;
    182. 	}
    183. 	struct LinkList* mylist = List;
    184. 	if (pos<0 || pos>mylist->_size - 1)
    185. 	{
    186. 		return;
    187. 	}
    188.  
    189. 	//找待删位置的前驱节点
    190. 	struct LinkListNode* pCurrent = &mylist->pHeader;
    191. 	for (int i = 0; i < pos; i++)
    192. 	{
    193. 		pCurrent = pCurrent->next;
    194. 	}
    195.  
    196. 	//记录待删除节点
    197. 	struct LinkListNode* pDel = pCurrent->next;
    198.  
    199. 	//更改指针指向
    200. 	pCurrent->next = pDel->next;
    201.  
    202. 	//更改指针长度
    203. 	mylist->_size--;
    204. }
    205.  
    206.  
    207.  
    208. //7.销毁链表函数实现
    209. void DestroyLinkList(pLinkList List)
    210. {
    211. 	if (List == NULL)
    212. 	{
    213. 		return;
    214. 	}
    215. 	free(List);
    216. 	List = NULL;
    217. }
    218.  
    219.  
    220.  
    221.  
    222.  
    223.  
    224.  
    225.  
    226.  
    227.  
    228.  
    229.  
    230.  
    231.  
    232.  
    233.  
    234.  
    235.  
    236.  
    237.  
    238.  
    239.  
    240.  
    241.  
    242.  
    243.  
    244.  
    245.  
    246.  
    247.  
    248.  
    249. //3.Single_Linked_List_Enterprise_Edition_Main.c部分
    250. #pragma once
    251. #define _CRT_SECURE_NO_WARNINGS
    252. #include 
    253. #include 
    254. #include 
    255. #include 
    256. #include 
    257. #include 
    258. #include 
    259. #include 
    260. #include 
    261. #include "Single_Linked_List_Enterprise_Edition_Head.h"
    262.  
    263.  
    264. //测试
    265.  
    266. //1.定义数据结构体
    267. struct Person
    268. {
    269. 	void* Node;
    270. 	char name[64];
    271. 	int age;
    272. };
    273.  
    274.  
    275.  
    276. //2.打印函数实现
    277. void Print(void* data)
    278. {
    279. 	struct Person* p = data;
    280. 	printf("姓名：%s 年龄：%d\n", p->name, p->age);
    281. }
    282.  
    283.  
    284.  
    285. int main()
    286. {
    287. 	//初始化链表
    288. 	pLinkList mylist = InitLinkList();
    289.  
    290. 	//创建数据
    291. 	struct Person p1 = { NULL,"aaa", 10 };
    292. 	struct Person p2 = { NULL,"bbb", 20 };
    293. 	struct Person p3 = { NULL,"ccc", 30 };
    294. 	struct Person p4 = { NULL,"ddd", 40 };
    295. 	struct Person p5 = { NULL,"eee", 50 };
    296.  
    297. 	//插入节点
    298. 	InsertLinkList(mylist, 0, &p1);
    299. 	InsertLinkList(mylist, 0, &p2);
    300. 	InsertLinkList(mylist, 1, &p3);
    301. 	InsertLinkList(mylist, -1, &p4);
    302. 	InsertLinkList(mylist, 0, &p5);
    303.  
    304.  
    305. 	//遍历链表
    306. 	DisplayLinkList(mylist, Print);
    307.  
    308. 	//删除
    309. 	DeleteLinkListNode(mylist, 3);
    310. 	printf("-----------------------\n");
    311. 	DisplayLinkList(mylist, Print);
    312.  
    313. 	//销毁
    314. 	DestroyLinkList(mylist);
    315. 	mylist = NULL;
    316. 	return 0;
    317. }

    输出结果

    1. 姓名：eee 年龄：50
    2. 姓名：ccc 年龄：30
    3. 姓名：bbb 年龄：20
    4. 姓名：ddd 年龄：40
    5. 姓名：aaa 年龄：10
    6. -----------------------
    7. 姓名：eee 年龄：50
    8. 姓名：ccc 年龄：30
    9. 姓名：bbb 年龄：20
    10. 姓名：aaa 年龄：10

    2.4线性表的链式存储(双向链表)

    链表有带头或不带头，循环或不循环的分类，下面仅以双向带头循环链表为例来实现链表的增删查改。

     1.创建三个文件

    2.代码

    1. //1.List.h 部分
    2. #define _CRT_SECURE_NO_WARNINGS
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12.  
    13.  
    14. //1.定义结构体
    15. typedef struct ListNode
    16. {
    17. 	int data;
    18. 	struct ListNode* next;
    19. 	struct ListNode* prev;
    20. }LN;
    21.  
    22.  
    23.  
    24. //2.获得新节点函数声明
    25. LN* BuyLTNode(LN* pList);
    26.  
    27.  
    28.  
    29. //3.初始化结构体函数声明
    30. void ListInit(LN** ppList);
    31.  
    32.  
    33. //4.插入函数声明
    34. void ListInsert(LN* pList);
    35.  
    36.  
    37.  
    38. //5.打印函数声明
    39. void ListPrint(LN* pList);
    40.  
    41.  
    42. //6.回收链表函数声明
    43. void ListDestroy(LN* pList);
    44.  
    45.  
    46. //7.头插函数声明
    47. void ListPushFrant(LN* pList);
    48.  
    49.  
    50. //8.头删函数声明
    51. void ListPopFrant(LN* pList);
    52.  
    53.  
    54. //9.尾插函数声明
    55. void ListPushBack(LN* pList);
    56.  
    57.  
    58. //10.尾删函数声明
    59. void ListPopBack(LN* pList);
    60.  
    61.  
    62. //11.删除节点函数声明
    63. void ListErase(LN* pList);
    64.  
    65.  
    66. //12.查找函数节点声明
    67. void ListFind(LN* pList);
    68.  
    69.  
    70.  
    71.  
    72.  
    73.  
    74.  
    75.  
    76.  
    77.  
    78.  
    79.  
    80.  
    81.  
    82.  
    83.  
    84.  
    85.  
    86.  
    87.  
    88.  
    89.  
    90.  
    91.  
    92.  
    93.  
    94.  
    95. //2.ListFunc.c 部分
    96. #define _CRT_SECURE_NO_WARNINGS
    97. #include 
    98. #include 
    99. #include 
    100. #include 
    101. #include 
    102. #include 
    103. #include 
    104. #include 
    105. #include 
    106. #include "List.h"
    107.  
    108.  
    109. //2.获得新节点函数实现
    110. LN* BuyLTNode(int x)
    111. {
    112. 	LN* newnode = (LN*)malloc(sizeof(LN));
    113. 	if (newnode == NULL)
    114. 	{
    115. 		printf("BuyLTNode::()%s\n", strerror(errno));
    116. 		exit(-1);
    117. 	}
    118. 	newnode->data = x;
    119. 	newnode->next = NULL;
    120. 	newnode->prev = NULL;
    121. 	return newnode;
    122. }
    123.  
    124.  
    125.  
    126. //3.初始化结构体函数实现
    127. void ListInit(LN** ppList)
    128. {
    129. 	assert(ppList);
    130. 	*ppList = BuyLTNode(0);
    131. 	(*ppList)->next = *ppList;
    132. 	(*ppList)->prev = *ppList;
    133. }
    134.  
    135.  
    136.  
    137. //4.插入函数实现
    138. void ListInsert(LN* pList)
    139. {
    140. 	assert(pList);
    141. 	if (pList->next == pList)
    142. 	{
    143. 		printf("暂无节点，请输入数值进行插值：");
    144. 		int x = 0;
    145. 		scanf("%d", &x);
    146. 		LN* newnode = BuyLTNode(x);
    147. 		newnode->next = pList;
    148. 		newnode->prev = pList;
    149.  
    150. 		pList->next = newnode;
    151. 		pList->prev = newnode;
    152. 	}
    153. 	else
    154. 	{
    155. 		printf("请输入要在哪个数值前面插值：");
    156. 		int y = 0;
    157. 		scanf("%d", &y);
    158. 		LN* cur = pList->next;
    159. 		while (cur != pList)
    160. 		{
    161. 			if (cur->data == y)
    162. 			{
    163. 				break;
    164. 			}
    165. 			cur = cur->next;
    166. 		}
    167. 		if (cur == pList)
    168. 		{
    169. 			printf("无此节点，请重新输入：\n");
    170. 			return;
    171. 		}
    172. 		printf("请输入要插入的值：");
    173. 		int val = 0;
    174. 		scanf("%d", &val);
    175. 		LN* newnode = BuyLTNode(val);
    176. 		newnode->prev = cur->prev;      //与前节点连接
    177. 		cur->prev->next = newnode;
    178.  
    179. 		newnode->next = cur;            //与后节点连接
    180. 		cur->prev = newnode;
    181. 	}
    182. 	printf("插入数值成功!\n");
    183. }
    184.  
    185.  
    186.  
    187. //5.打印函数实现
    188. void ListPrint(LN* pList)
    189. {
    190. 	assert(pList);
    191. 	LN* cur = pList->next;
    192. 	while (cur != pList)
    193. 	{
    194. 		printf("%d ", cur->data);
    195. 		cur = cur->next;
    196. 	}
    197. 	printf("\n");
    198. }
    199.  
    200.  
    201.  
    202. //6.回收链表函数实现
    203. void ListDestroy(LN* pList)
    204. {
    205. 	assert(pList);
    206. 	LN* Cur = pList->next;
    207. 	LN* CurNext = Cur->next;
    208. 	while (Cur != pList)
    209. 	{
    210. 		CurNext = Cur->next;                //先保存下一个节点
    211.  
    212. 		Cur->next = NULL;
    213. 		Cur->prev = NULL;
    214. 		free(Cur);
    215. 		Cur = NULL;
    216.  
    217. 		Cur = CurNext;               
    218. 	}
    219. 	pList->next = NULL;
    220. 	pList->prev = NULL;
    221. 	free(pList);
    222. 	pList = NULL;
    223. 	printf("回收空间成功，退出链表\n");
    224. }
    225.  
    226.  
    227.  
    228. //7.头插函数实现
    229. void ListPushFrant(LN* pList)
    230. {
    231. 	assert(pList);
    232. 	printf("请输入要头插的数值：");
    233. 	int x = 0;
    234. 	scanf("%d", &x);
    235. 	LN* newnode = BuyLTNode(x);
    236. 	newnode->next = pList->next;     //与后节点连接
    237. 	pList->next->prev = newnode;
    238.  
    239. 	newnode->prev = pList;           //与哨兵位连接
    240. 	pList->next = newnode;
    241. 	printf("头插函数成功!\n");
    242. }
    243.  
    244.  
    245.  
    246. //8.头删函数实现
    247. void ListPopFrant(LN* pList)
    248. {
    249. 	assert(pList);
    250. 	if (pList->next == pList)
    251. 	{
    252. 		printf("无节点，无法头删\n");
    253. 		return;
    254. 	}
    255. 	LN* pos = pList->next;
    256.  
    257. 	pList->next->next->prev = pList;
    258. 	pList->next = pList->next->next;
    259.  
    260. 	pos->next = NULL;
    261. 	pos->prev = NULL;
    262. 	free(pos);
    263. 	printf("头删成功!\n");
    264. }
    265.  
    266.  
    267.  
    268. //9.尾插函数实现
    269. void ListPushBack(LN* pList)
    270. {
    271. 	assert(pList);
    272. 	printf("请输入要尾插的数值：");
    273. 	int x = 0;
    274. 	scanf("%d", &x);
    275. 	LN* newnode = BuyLTNode(x);
    276. 	newnode->prev = pList->prev;
    277. 	pList->prev->next = newnode;
    278.  
    279. 	newnode->next = pList;
    280. 	pList->prev = newnode;
    281. 	printf("尾插成功!\n");
    282. }
    283.  
    284.  
    285.  
    286. //10.尾删函数实现
    287. void ListPopBack(LN* pList)
    288. {
    289. 	assert(pList);
    290. 	if (pList->next == pList)
    291. 	{
    292. 		printf("无节点，无法尾删\n");
    293. 		return;
    294. 	}
    295. 	LN* pos = pList->prev;
    296. 	pList->prev->prev->next = pList;
    297. 	pList->prev = pList->prev->prev;
    298.  
    299. 	pos->next = NULL;
    300. 	pos->prev = NULL;
    301. 	free(pos);
    302. 	printf("尾删成功!\n");
    303. }
    304.  
    305.  
    306.  
    307. //11.删除节点函数实现
    308. void ListErase(LN* pList)
    309. {
    310. 	assert(pList);
    311. 	if (pList->next == pList)
    312. 	{
    313. 		printf("无节点，无法删除\n");
    314. 		return;
    315. 	}
    316. 	printf("请输入要删除的数值：");
    317. 	int x = 0;
    318. 	scanf("%d", &x);
    319. 	LN* cur = pList->next;
    320. 	while (cur != pList)
    321. 	{
    322. 		if (cur->data == x)
    323. 		{
    324. 			break;
    325. 		}
    326. 		cur = cur->next;
    327. 	}
    328. 	if (cur == pList)
    329. 	{
    330. 		printf("无该节点，无法删除\n");
    331. 		return;
    332. 	}
    333. 	cur->next->prev = cur->prev;
    334. 	cur->prev->next = cur->next;
    335.  
    336. 	cur->next = NULL;
    337. 	cur->prev = NULL;
    338. 	free(cur);
    339. 	printf("删除节点成功\n");
    340. }
    341.  
    342.  
    343.  
    344. //12.查找函数节点实现
    345. void ListFind(LN* pList)
    346. {
    347. 	assert(pList);
    348. 	if (pList->next == pList)
    349. 	{
    350. 		printf("无节点，无法查找\n");
    351. 		return;
    352. 	}
    353. 	printf("请输入要查找的数值：");
    354. 	int x = 0;
    355. 	scanf("%d", &x);
    356. 	LN* cur = pList->next;
    357. 	while (cur != pList)
    358. 	{
    359. 		if (cur->data == x)
    360. 		{
    361. 			break;
    362. 		}
    363. 		cur = cur->next;
    364. 	}
    365. 	if (cur == pList)
    366. 	{
    367. 		printf("无该节点\n");
    368. 		return;
    369. 	}
    370. 	printf("数值%d的地址为%p\n", x, cur);
    371. }
    372.  
    373.  
    374.  
    375.  
    376.  
    377.  
    378.  
    379.  
    380.  
    381.  
    382.  
    383.  
    384.  
    385.  
    386.  
    387.  
    388.  
    389.  
    390.  
    391.  
    392.  
    393.  
    394.  
    395.  
    396.  
    397.  
    398. //3.List.c 部分
    399. #define _CRT_SECURE_NO_WARNINGS
    400. #include 
    401. #include 
    402. #include 
    403. #include 
    404. #include 
    405. #include 
    406. #include 
    407. #include 
    408. #include 
    409. #include "List.h"
    410.  
    411.  
    412.  
    413. enum Option
    414. {
    415. 	退出链表,
    416. 	头插,
    417. 	头删,
    418. 	尾插,
    419. 	尾删,
    420. 	随机插值,
    421. 	删除数值,
    422. 	查找数值,
    423. 	打印链表
    424. };
    425.  
    426.  
    427.  
    428. void menu()
    429. {
    430. 	printf("*****************************************\n");
    431. 	printf("******     1.头插       2.头删     ******\n");
    432. 	printf("******     3.尾插       4.尾删     ******\n");
    433. 	printf("******     5.随机插值   6.删除数值 ******\n");
    434. 	printf("******     7.查找数值   8.打印链表 ******\n");
    435. 	printf("******     0.退出链表              ******\n");
    436. 	printf("*****************************************\n");
    437. }
    438.  
    439.  
    440.  
    441. int main()
    442. {
    443. 	LN* pList = NULL;
    444. 	ListInit(&pList);
    445. 	int input = 0;
    446. 	do
    447. 	{
    448. 		menu();
    449. 		printf("请输入要进行的操作：");
    450. 		scanf("%d", &input);
    451. 		switch (input)
    452. 		{
    453. 		case (头插):
    454. 			ListPushFrant(pList);
    455. 			break;
    456. 		case (头删):
    457. 			ListPopFrant(pList);
    458. 			break;
    459. 		case (尾插):
    460. 			ListPushBack(pList);
    461. 			break;
    462. 		case (尾删):
    463. 			ListPopBack(pList);
    464. 			break;
    465. 		case (随机插值):
    466. 			ListInsert(pList);
    467. 			break;
    468. 		case (删除数值):
    469. 			ListErase(pList);
    470. 			break;
    471. 		case (查找数值):
    472. 			ListFind(pList);
    473. 			break;
    474. 		case (打印链表):
    475. 			ListPrint(pList);
    476. 			break;
    477. 		case (退出链表):
    478. 			ListDestroy(pList);
    479. 			break;
    480. 		default:
    481. 			printf("输入有误，请重新输入\n");
    482. 			break;
    483. 		}
    484. 	} while (input);
    485. 	return 0;
    486. }

     

  • 相关阅读:
    代理IP和Socks5代理：跨界电商与全球爬虫的关键技术
    二百零二、Hive——Hive解析JSON字段（单个字段与json数组）
    Python 中的内存泄漏问题
    RT-Thread 中断管理（学习三）
    【OpenCV-PyQt5-PyGame-imutils】探索Python中的图像和视频捕获：性能分析与选择指南
    20230904工作心得：集合应该如何优雅判空？
    Sulfo-Cyanine7 NHS ester活体成像用染料1603861-95-5星戈瑞
    typename 的用法
    Python - 异常处理
    pytorch中detach()函数以及data属性的区别+梯度求导计算
  • 原文地址：https://blog.csdn.net/qq_43205256/article/details/126010259