devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【数据结构】【C语言】------ 单链表_单链表c语言

作者：Cpp五条 | 2024-05-12 02:07:38

赞

踩

单链表c语言

前言

大家好，我是Abert。

这篇文章和大家分享用C语言实现数据结构中的单链表。

单链表可以看作是“拆分开”的顺序表。在顺序表的基础上，单链表做了一些优化，但同时也丧失了一些顺序表有的功能。

我们一起来学习单链表吧！！！

文章目录

一、单链表的讲解

二、程序基本框架的搭建与讲解

        2.1 文件的创建

        2.2 变量的创建

三、各种功能的实现及逻辑关系的讲解

        3.1 尾插

        3.2 头插

        3.3 尾删

        3.4 头删

        3.5 查询

        3.6 在pos位置之前插入

        3.7 删除pos位置的值

        3.8 在pos位置之后插入x

        3.9 删除pos之后的值

四、完整代码

        4.1  SLlist.h    

        4.2  SLlist.c

        4.3  test.c

五、优缺点的分析 

正文

一、单链表的讲解

上图可以看作是单链表的一个简单结构，多个节点链接起来（实际在内存中的存储可能不是这样的一条规则的链）

链表插入数据不会像顺序表一样一次开辟很多空间，插入一个类型的数据，开辟一个节点，通过改变指针的指向来把新数据与原数据串接起来，如下图 

同理，单链表删除数据也只需要改变指针的指向的空间，然后free掉要删除的空间。 

如下图：

 

二、程序基本框架的搭建与讲解

2.1 文件的创建

该项目要创建三个文件。

头文件 SLlist.h    （存放程序中需要的头文件以及声明实现功能的函数）

源文件 SLlist.c    （存放实现程序功能的代码）

源文件 test.c          (存放主函数及测试函数功能的代码）

 2.2 变量的创建

  1. typedef int SLDataType;
  2.  
  3. typedef struct SLlistNode
  4. {
  5. 	SLDataType data;//存放数据
  6. 	struct SLlistNode* next;//节点
  7.  
  8. }SLTNode;

这里创建好结构体来成为单链表的子结构，假设创建了一些结构体变量：

SLTNode* n1, *n2, *n3, *n4;

把它们链接起来只需要改变它们内部指针变量的指向。如下：

n1->next = n2;

n2->next = n3;

n3->next = n4;

n4->next = NULL;

如此这些节点会链接起来，就是一个简单的单链表。

三、各种功能的实现及逻辑关系的讲解 

  3.1 尾插

这里利用了二级指针，改变结构体指针需要传入该指针的地址，即为二级指针。

下面需要改变头节点的功能皆需要二级指针

（可以不使用二级指针，但必须return 一个 SLTNode* 的头节点指针。）

本文使用二级指针的方式。

  1. //尾插
  2. void SLlistPushBack(SLTNode** pphead, SLDataType x)
  3. {
  4. 	assert(pphead);
  5. 	SLTNode* newnode = BuySLlistNode(x);
  6.  
  7. 	if (*pphead == NULL)
  8. 	{
  9. 		*pphead = newnode;
  10. 	}
  11. 	else
  12. 	{
  13. 		//找尾节点
  14. 		SLTNode* tail = *pphead;
  15. 		while (tail->next != NULL)
  16. 		{
  17. 			tail = tail->next;
  18. 		}
  19.  
  20. 		tail->next = newnode;
  21. 	}
  22.  
  23. }

   3.2 头插

  1. //头插
  2. void SLlistPushFront(SLTNode** pphead, SLDataType x)
  3. {
  4. 	assert(pphead);
  5.  
  6. 	SLTNode* newnode = BuySLlistNode(x);
  7. 	newnode->next = *pphead;
  8. 	*pphead = newnode;
  9. }

3.3 尾删

  1. //尾删
  2. void SLlistPopBack(SLTNode** pphead)
  3. {
  4. 	assert(pphead);
  5. 	assert(*pphead);
  6.  
  7. 	//1.只有一个节点
  8. 	//2.有多个节点
  9. 	if ((*pphead)->next == NULL)
  10. 	{
  11. 		free(*pphead);
  12. 		*pphead = NULL;
  13. 	}
  14. 	else
  15. 	{
  16. 		SLTNode* tail = *pphead;
  17. 		while (tail->next->next != NULL)
  18. 		{
  19. 			tail = tail->next;
  20. 		}
  21. 		free(tail->next);
  22. 		tail->next = NULL;
  23. 	}
  24.  
  25. }

3.4 头删

  1. //头删
  2. void SLlistPopFront(SLTNode** pphead)
  3. {
  4. 	assert(pphead);
  5. 	assert(*pphead);
  6. 	SLTNode* next = (*pphead)->next;
  7. 	free(*pphead);
  8. 	*pphead = next;
  9.  
  10. }

3.5 查询

  1. //查询
  2. SLTNode* SLlistFind(SLTNode* phead, SLDataType x)
  3. {
  4. 	SLTNode* cur = phead;
  5. 	while (cur)
  6. 	{
  7. 		if (cur->data = x)
  8. 		{
  9. 			return cur;
  10. 			cur = cur->next;
  11. 		}
  12. 	}
  13.  
  14. 	return NULL;
  15. }

3.6 在pos位置之前插入

  1. //在pos位置之前插入
  2. void SLlistInsert(SLTNode** pphead, SLTNode* pos, SLDataType x)
  3. {
  4. 	assert(pos);
  5. 	assert(pphead);
  6.  
  7. 	//头插
  8. 	if (pos == *pphead)
  9. 	{
  10. 		SLlistPushFront(pphead, x);
  11. 	}
  12. 	else
  13. 	{
  14. 		SLTNode* prev = *pphead;
  15. 		while (prev->next != pos)
  16. 		{
  17. 			prev = prev->next;
  18. 		}
  19.  
  20. 		SLTNode* newnode = BuySLlistNode(x);
  21. 		prev->next = newnode;
  22. 		newnode->next = pos;
  23. 	}
  24.  
  25. }

3.7 删除pos位置的值 

  1. //删除pos位置的值
  2. void SLlistErase(SLTNode** pphead, SLTNode* pos)
  3. {
  4. 	assert(pphead);
  5. 	assert(pos);
  6.  
  7. 	//头删
  8. 	if (pos = *pphead)
  9. 	{
  10. 		SLlistPopFront(pphead);
  11. 	}
  12. 	else
  13. 	{
  14. 		SLTNode* prev = *pphead;
  15. 		while (prev->next != pos)
  16. 		{
  17. 			prev = prev->next;
  18.  
  19. 		}
  20. 		prev->next = pos->next;
  21.  
  22. 		free(pos);
  23. 		pos = NULL;
  24. 	}
  25.  
  26. }

3.8 在pos位置之后插入x

  1. //在pos位置之后插入x
  2. void SLlistInsertAfter(SLTNode** pphead, SLTNode* pos, SLDataType x)
  3. {
  4. 	assert(pos);
  5.  
  6. 	SLTNode* newnode = BuySLlistNode(x);
  7. 	SLTNode* next = pos->next;
  8. 	pos->next = newnode;
  9. 	newnode->next = next;
  10.  
  11. }

3.9 删除pos之后的值

  1. //删除pos之后的值
  2. void SLlistEraseAfter(SLTNode* pos)
  3. {
  4. 	assert(pos);
  5.  
  6. 	if (pos->next == NULL)
  7. 	{
  8. 		return;
  9. 	}
  10. 	SLTNode* del = pos->next;
  11. 	pos->next = del->next;
  12.  
  13. 	free(del);
  14. 	del = NULL;
  15. }

四、完整代码

        4.1  SLlist.h    

  1. #pragma once
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <assert.h>
  5.  
  6. typedef int SLDataType;
  7.  
  8. typedef struct SLlistNode
  9. {
  10. 	SLDataType data;
  11. 	struct SLlistNode* next;
  12.  
  13. }SLTNode;
  14.  
  15. //初始化单链表
  16. SLTNode* BuySLlistNode(SLDataType x);
  17.  
  18. //打印单链表
  19. void SLPrint(SLTNode* phead);
  20.  
  21. //尾插
  22. void SLlistPushBack(SLTNode** pphead, SLDataType x);
  23.  
  24. //头插
  25. void SLlistPushFront(SLTNode** pphead, SLDataType x);
  26.  
  27. //尾删
  28. void SLlistPopBack(SLTNode** pphead);
  29.  
  30. //头删
  31. void SLlistPopFront(SLTNode** pphead);
  32.  
  33. //查询
  34. SLTNode* SLlistFind(SLTNode* phead, SLDataType x);
  35.  
  36. //在pos位置之前插入
  37. void SLlistInsert(SLTNode** pphead, SLTNode* pos, SLDataType x);
  38.  
  39. //删除pos位置的值
  40. void SLlistErase(SLTNode** pphead, SLTNode* pos);
  41.  
  42. //在pos位置之后插入x
  43. void SLlistInsertAfter(SLTNode** pphead, SLTNode* pos, SLDataType x);
  44.  
  45. //删除pos之后的值
  46. void SLlistEraseAfter(SLTNode* pos);

        4.2  SLlist.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include"SLlist.h"
  3.  
  4.  
  5. //创建一个节点
  6. SLTNode* BuySLlistNode(SLDataType x)
  7. {
  8. 	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
  9. 	assert(newnode);
  10. 	newnode->data = x;
  11. 	newnode->next = NULL;
  12.  
  13. 	return newnode;
  14. }
  15.  
  16.  
  17. //打印单链表
  18. void SLPrint(SLTNode* phead)
  19. {
  20. 	SLTNode* cur = phead;
  21. 	while (cur != NULL)
  22. 	{
  23. 		printf("%d->", cur->data);
  24. 		cur = cur->next;
  25. 	}
  26. 	printf("NULL\n");
  27. 	
  28. }
  29.  
  30.  
  31. //尾插
  32. void SLlistPushBack(SLTNode** pphead, SLDataType x)
  33. {
  34. 	assert(pphead);
  35. 	SLTNode* newnode = BuySLlistNode(x);
  36.  
  37. 	if (*pphead == NULL)
  38. 	{
  39. 		*pphead = newnode;
  40. 	}
  41. 	else
  42. 	{
  43. 		//找尾节点
  44. 		SLTNode* tail = *pphead;
  45. 		while (tail->next != NULL)
  46. 		{
  47. 			tail = tail->next;
  48. 		}
  49.  
  50. 		tail->next = newnode;
  51. 	}
  52.  
  53. }
  54.  
  55.  
  56. //头插
  57. void SLlistPushFront(SLTNode** pphead, SLDataType x)
  58. {
  59. 	assert(pphead);
  60.  
  61. 	SLTNode* newnode = BuySLlistNode(x);
  62. 	newnode->next = *pphead;
  63. 	*pphead = newnode;
  64. }
  65.  
  66.  
  67. //尾删
  68. void SLlistPopBack(SLTNode** pphead)
  69. {
  70. 	assert(pphead);
  71. 	assert(*pphead);
  72.  
  73. 	//1.只有一个节点
  74. 	//2.有多个节点
  75. 	if ((*pphead)->next == NULL)
  76. 	{
  77. 		free(*pphead);
  78. 		*pphead = NULL;
  79. 	}
  80. 	else
  81. 	{
  82. 		SLTNode* tail = *pphead;
  83. 		while (tail->next->next != NULL)
  84. 		{
  85. 			tail = tail->next;
  86. 		}
  87. 		free(tail->next);
  88. 		tail->next = NULL;
  89. 	}
  90.  
  91. }
  92.  
  93.  
  94. //头删
  95. void SLlistPopFront(SLTNode** pphead)
  96. {
  97. 	assert(pphead);
  98. 	assert(*pphead);
  99. 	SLTNode* next = (*pphead)->next;
  100. 	free(*pphead);
  101. 	*pphead = next;
  102.  
  103. }
  104.  
  105.  
  106. //查询
  107. SLTNode* SLlistFind(SLTNode* phead, SLDataType x)
  108. {
  109. 	SLTNode* cur = phead;
  110. 	while (cur)
  111. 	{
  112. 		if (cur->data = x)
  113. 		{
  114. 			return cur;
  115. 			cur = cur->next;
  116. 		}
  117. 	}
  118.  
  119. 	return NULL;
  120. }
  121.  
  122.  
  123. //在pos位置之前插入
  124. void SLlistInsert(SLTNode** pphead, SLTNode* pos, SLDataType x)
  125. {
  126. 	assert(pos);
  127. 	assert(pphead);
  128.  
  129. 	//头插
  130. 	if (pos == *pphead)
  131. 	{
  132. 		SLlistPushFront(pphead, x);
  133. 	}
  134. 	else
  135. 	{
  136. 		SLTNode* prev = *pphead;
  137. 		while (prev->next != pos)
  138. 		{
  139. 			prev = prev->next;
  140. 		}
  141.  
  142. 		SLTNode* newnode = BuySLlistNode(x);
  143. 		prev->next = newnode;
  144. 		newnode->next = pos;
  145. 	}
  146.  
  147. }
  148.  
  149.  
  150. //删除pos位置的值
  151. void SLlistErase(SLTNode** pphead, SLTNode* pos)
  152. {
  153. 	assert(pphead);
  154. 	assert(pos);
  155.  
  156. 	//头删
  157. 	if (pos = *pphead)
  158. 	{
  159. 		SLlistPopFront(pphead);
  160. 	}
  161. 	else
  162. 	{
  163. 		SLTNode* prev = *pphead;
  164. 		while (prev->next != pos)
  165. 		{
  166. 			prev = prev->next;
  167.  
  168. 		}
  169. 		prev->next = pos->next;
  170.  
  171. 		free(pos);
  172. 		pos = NULL;
  173. 	}
  174.  
  175. }
  176.  
  177.  
  178. //在pos位置之后插入x
  179. void SLlistInsertAfter(SLTNode** pphead, SLTNode* pos, SLDataType x)
  180. {
  181. 	assert(pos);
  182.  
  183. 	SLTNode* newnode = BuySLlistNode(x);
  184. 	SLTNode* next = pos->next;
  185. 	pos->next = newnode;
  186. 	newnode->next = next;
  187.  
  188. }
  189.  
  190.  
  191. //删除pos之后的值
  192. void SLlistEraseAfter(SLTNode* pos)
  193. {
  194. 	assert(pos);
  195.  
  196. 	if (pos->next == NULL)
  197. 	{
  198. 		return;
  199. 	}
  200. 	SLTNode* del = pos->next;
  201. 	pos->next = del->next;
  202.  
  203. 	free(del);
  204. 	del = NULL;
  205. }

        4.3  test.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include"SLlist.h"
  3.  
  4. //测试尾插
  5. void TestSList1()
  6. {
  7. 	//struct SListNode* 
  8. 	SLTNode* n1 = (SLTNode*)malloc(sizeof(SLTNode));
  9. 	assert(n1);
  10. 	SLTNode* n2 = (SLTNode*)malloc(sizeof(SLTNode));
  11. 	assert(n2);
  12. 	SLTNode* n3 = (SLTNode*)malloc(sizeof(SLTNode));
  13. 	assert(n3);
  14. 	SLTNode* n4 = (SLTNode*)malloc(sizeof(SLTNode));
  15. 	assert(n4);
  16.  
  17. 	n1->data = 1;
  18. 	n2->data = 2;
  19. 	n3->data = 3;
  20. 	n4->data = 4;
  21.  
  22. 	n1->next = n2;
  23. 	n2->next = n3;
  24. 	n3->next = n4;
  25. 	n4->next = NULL;
  26.  
  27. 	SLTNode* plist = n1;
  28. 	SListPrint(plist);
  29.  
  30. 	SListPushBack(&plist, 5);
  31. 	SListPushBack(&plist, 6);
  32. 	SListPushBack(&plist, 7);
  33. 	SListPushBack(&plist, 8);
  34. 	SListPrint(plist);
  35. }
  36.  
  37.  
  38.  
  39. //测试头插
  40. void TestSList2()
  41. {
  42. 	SLTNode* plist = NULL;
  43. 	SListPushFront(&plist, 0);
  44. 	SListPushFront(&plist, 1);
  45. 	SListPushFront(&plist, 2);
  46. 	SListPushFront(&plist, 3);
  47. 	SListPushFront(&plist, 4);
  48. 	SListPrint(plist);
  49.  
  50. 	SListPopFront(&plist);
  51. 	SListPopFront(&plist);
  52. 	SListPopFront(&plist);
  53. 	SListPopFront(&plist);
  54. 	SListPopFront(&plist);
  55. 	//SListPopFront(&plist);
  56. 	SListPrint(plist);
  57. }
  58.  
  59.  
  60. //测试尾插与尾删
  61. void TestSList3()
  62. {
  63. 	SLTNode* plist = NULL;
  64. 	SListPushBack(&plist, 1);
  65. 	SListPushBack(&plist, 2);
  66. 	SListPushBack(&plist, 3);
  67. 	SListPushBack(&plist, 4);
  68.  
  69. 	SListPrint(plist);
  70.  
  71. 	SListPopBack(&plist);
  72. 	SListPrint(plist);
  73.  
  74. 	SListPopBack(&plist);
  75. 	SListPrint(plist);
  76.  
  77. 	SListPopBack(&plist);
  78. 	SListPrint(plist);
  79.  
  80. 	SListPopBack(&plist);
  81. 	SListPrint(plist);
  82.  
  83. 	//SListPopBack(&plist);
  84. 	//SListPrint(plist);
  85. }
  86.  
  87.  
  88. //测试查询
  89. void TestSList4()
  90. {
  91. 	SLTNode* plist = NULL;
  92. 	SListPrint(plist);
  93.  
  94. 	SListPushBack(&plist, 1);
  95. 	SListPushBack(&plist, 2);
  96. 	SListPushBack(&plist, 3);
  97. 	SListPushBack(&plist, 4);
  98. 	SListPrint(plist);
  99.  
  100. 	SLTNode* ret = SListFind(plist, 3);
  101. 	if (ret)
  102. 	{
  103. 		printf("找到了\n");
  104. 		ret->data = 30;
  105. 	}
  106. 	SListPrint(plist);
  107.  
  108.  
  109. 	SLTNode* pos = SListFind(plist, 4);
  110. 	if (pos)
  111. 	{
  112. 		SListInsert(&plist, pos, 40);
  113. 	}
  114. 	SListPrint(plist);
  115.  
  116. 	//SListPushBack(NULL, 1);
  117.  
  118. 	//SListInsert(&plist, NULL, 40);
  119. 	//SListPrint(plist);
  120.  
  121. 	pos = SListFind(plist, 4);
  122. 	if (pos)
  123. 	{
  124. 		SListErase(&plist, pos);
  125. 	}
  126. 	SListPrint(plist);
  127. }
  128.  
  129. int main()
  130. {
  131. 	//测试哪个模块的功能，只需解引用该模块的函数
  132.  
  133. 	/*TestSList1();
  134. 	TestSList2();
  135. 	TestSList3();*/
  136. 	TestSList4();
  137.  
  138. 	return 0;
  139. }

五、优缺点的分析

单链表的优点：

        单链表中插入一个类型的数据仅需开辟一个结点的空间，空间利用率高。

        删除数据只需释放结点的空间，不需要挪动数据。

        任意删除或添加数据，时间复杂度尾O(1)

单链表的缺点：

        单链表中任意删除/添加/查找/修改的功能不能使用（不支持数据的随机访问）。

总结

单链表相比顺序表有些许提升，但同时也存在一系列问题。

总体来说，需要不断插入删除数据的时候，采用单链表会比顺序表效率高。

以上就是这篇文章的全部内容，希望对大家有帮助。 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/557100
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号