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

【数据结构】单链表的实现_实现单链表

作者：我家小花儿 | 2024-06-04 06:34:22

赞

踩

实现单链表

老当益壮，宁移白首之心；穷且益坚，不坠青云之志。                        ——王勃

目录

前言：

一.单链表的定义

二.链表的几种模型

三.前期的准备 

四.单链表的实现

1.单链表的尾插

2.打印函数

2.单链表的头插 

3.单链表的头删 

4.单链表的尾删 

5.查找数字操作 

6.把pos位置的数字删除

7.在pos位置前面的位置插入数字 

五.全部代码 

1.SList.h:

2.SList.c:

3.test.c:

前言：

距离我们学习顺序表已经过去了二十天了，最近一直太忙了，一直学习单链表，这两天把链表学了一下，准备和大家分享一下。过两天再把双链表更了。望老铁们支持一下。

虽然上次我们实现的是动态的顺序表，但是顺序表有以下的缺点：
1.如果空间不够了，需要增容。增容会付出一定性能消耗，其次可能存在一定的空间浪费。
2.头部或者中部左右的插入删除效率低。时间复杂度是O(N)。

根据以上的缺点，大佬设计出了链表。

一.单链表的定义

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

这里需要存放一个数据元素和一个地址所以我们还是和顺序表一样创建结构体来存放。

  1. typedef int SLTDataType;
  2. typedef struct SLTNode
  3. {
  4. 	  SLTDataType data;
  5. 	  struct SLTNode* next;
  6. }SLTNode;

注意这里一定不能写成：

链表的优点：
1.链表的内存空间不连续。
2.如果知道要处理节点的前一个位置，则进行插入和删除的复杂度为O(1);
3.如果不知道要处理节点的前一个位置，则进行插入和删除的复杂度为O(N)。
4.头插、头删的效率高，时间复杂度是O(1)。
5.没有空间限制，不会溢出，可以存储很多元素。

二.链表的几种模型

链表的结构是有无头结点，有无循环，是单链还是双链。它们一共组合起来有八种结构。


第一种:无头无循环单链
第二种:无头无循环双链
第三种:无头循环单链
第四种:无头循环双链
第五种:有头无循环单链
第六种:有头无循环双链
第七种:有头循环单链
第八种:有头循环双链

而我们主要讲两种,一种是今天要说的无头无循环单链表，另一种是有头有循环双链表。

 无头无循环单链表:

有头循环双链:
 

这两个图都是我们想象出来的,为逻辑结构，实际上链表真正的结构是物理结构。
因为地址链表的地址是不连续的，所以这里的地址都是假设的。

三.前期的准备 

在实现链表的时候我们还是一样创建三个文件:
1.SList.h:存放各种的头文件和函数的声明。
2.SList.c:各种函数的实现。
3.test.c:执行代码的整体逻辑。

这里我们就不像顺序表那样写菜单了，如果有兴趣可以参考顺序表的菜单实现。

四.单链表的实现

1.单链表的尾插

因为后面多处会用到申请新结点，所以我们把申请新结点封装成一个函数，每次使用的时候,只需要调用一下这个函数即可，用起来非常的方便。
申请新结点:

  1. SLTNode* BuySListNode(SLTDataType x)
  2. {
  3. 	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
  4. 	newnode->data = x;
  5. 	newnode->next = NULL;//最后一个next赋值为NULL
  6. 	return newnode;
  7. }

尾插: 

  1. void SListPushBack(SLTNode** pphead, SLTDataType x)
  2. {
  3. 	SLTNode* newnode=BuySListNode(x);
  4. 	if (*pphead == NULL)
  5. 	{//这里一点定要判断一下，第一次尾插的时候就是NULL
  6. 	 //如果*pphead为空的时候，必须把它设置为新结点
  7. 		*pphead = newnode;
  8. 	}
  9. 	else
  10. 	{
  11. 		SLTNode* tail = *pphead;
  12. 		while (tail->next != NULL)//当链表结束的时候，最后一个next都是赋值为NULL
  13. 		{
  14. 			tail = tail->next;
  15. 		}
  16. 		tail->next = newnode;
  17. 	}
  18. }

尾插了之后我们可以打印出来看一下，我们在写代码的时候一定要写一部分，测试一部分。不要把代码写完了才开始测试，到时候一堆bug，非常的难受。所以我现在写一个打印函数来测测尾插有没有问题。

2.打印函数

  1. void SListprint(SLTNode* phead)
  2. {
  3. 	SLTNode* cur = phead;
  4. 	while (cur != NULL)//也就是看上一个结点的next地址为不为空
  5. 	{
  6. 		printf("%d ", cur->data);
  7. 		cur = cur->next;//这里的地址不是连续的,一定不能使用cur++
  8. 	}
  9. 	printf("\n");
  10. }

2.单链表的头插 

头插是非常简单的,也就是在第一个结点的前面插入一个数字。
把新结点的next链接到一个结点上，再把开辟的新结点赋值为第一个结点。

  1. void SListPushFront(SLTNode** pphead, SLTDataType x)
  2. {
  3. 	SLTNode* newnode = BuySListNode(x);
  4. 	newnode->next = *pphead;
  5. 	*pphead = newnode;//开辟的新节点赋值为第一个结点
  6. }

3.单链表的头删 

头删就是把第一个结点的地址给free掉，但是我们不能直接free掉，如果我们直接free掉，就找不到下一个结点的位置了，所以再我们free掉之前，我们要先保存一下第二个结点的地址，最后再把
第一个结点给free掉，再把第二个结点改为第一个结点。

  1. void SListPopFront(SLTNode** pphead)
  2. {
  3. 	SLTNode* next = (*pphead)->next;//记录第二个结点的位置
  4. 	free(*pphead);
  5. 	*pphead = NULL;
  6. 	*pphead = next;//把第二个结点改为第一个结点
  7. }

4.单链表的尾删 

对于链表的尾删我们要考虑仔细点，一共有三种情况:
第一种:如果链表为空，也没有要删的，直接return就好了。
第二种:如果链表只有一个结点，我们直接free掉即可。
第三种:如果链表有两个或者两个以上的结点时，我们设置两个指针，一个找最后的位置，一个找倒数第二个位置，我们找到next为空的地方，然后释放掉这个结点。然后把上一个结点的next赋值为NULL。

  1. void SListPopBack(SLTNode** pphead)
  2. {
  3. 	SLTNode* tail = *pphead;
  4. 	SLTNode* prev = NULL;
  5. 	//1.链表为空链表的时候
  6. 	if (*pphead == NULL)
  7. 	{
  8. 		return;
  9. 	}
  10. 	//2.链表只有一个节点的时候
  11. 	else if ((*pphead)->next == NULL)
  12. 	{
  13. 		free(*pphead);
  14. 		*pphead = NULL;
  15. 	}
  16. 	//3.链表有两个及两个以上的节点时
  17. 	else
  18. 	{
  19. 		while (tail->next != NULL)
  20. 		{
  21. 			prev = tail;
  22. 			tail = tail->next;
  23. 		}
  24. 		free(tail);
  25. 		prev->next = NULL;
  26. 	}
  27. }

5.查找数字操作 

这个非常简单，就是从第一个结点开始遍历整个链表，如果找到了，直接返回这个地址即可，如果遍历完了都没找到，直接返回NULL。

  1. SLTNode* SListFind(SLTNode* phead, SLTDataType x)
  2. {
  3. 	SLTNode* cur = phead;
  4. 	while (cur)
  5. 	{
  6. 		if (cur->data == x)
  7. 		{
  8. 			return cur;
  9. 		}
  10. 		cur = cur->next;
  11. 	}
  12. 	return NULL;
  13. }

6.把pos位置的数字删除

删除数字，肯定链表中要有这个数字才行，所以在删除之前我们要调用查找函数，看看要删除的数字有没有。
如果第一个结点就是我们要删除的数字，就相当于是头删，我们直接调用头删的函数即可。
不是第一个结点的时候，我们就要判断。

  1. void SListErase(SLTNode** pphead, SLTNode* pos)
  2. {
  3. 	if (*pphead == pos)
  4. 	{
  5. 		SListPopFront(pphead);
  6. 	}
  7. 	else
  8. 	{
  9. 		SLTNode* prev = *pphead;
  10. 		while (prev->next != pos)
  11. 		{
  12. 			prev = prev->next;
  13. 		}
  14. 		prev->next = pos->next;
  15. 		free(pos);
  16. 	}
  17. }

7.在pos位置前面的位置插入数字 

肯定链表中要有pos这个位置数字才行，所以在插入之前我们要调用查找函数，看看要pos位置的数字有没有。再往pos位置前面的位置插入数字 
这个也是分两种情况，如果链表结点只有一个，就相当于是头插，直接调用头插的函数。
第二种也是和pos位置删除的函数实现差不多，都是设置两个指针实现。

  1. void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
  2. {
  3. 	if (pos == *pphead)
  4. 	{
  5. 		SListPushFront(pphead, x);
  6. 	}
  7. 	else
  8. 	{
  9. 		SLTNode* newnode = BuySListNode(x);
  10. 		SLTNode* prev = *pphead;
  11. 		while (prev->next != pos)
  12. 		{
  13. 			prev = prev->next;
  14. 		}
  15. 		prev->next = newnode;
  16. 		newnode->next = pos;
  17. 	}
  18. }

五.全部代码 

1.SList.h:

  1. #pragma once
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4. typedef int SLTDataType;
  5. typedef struct SLTNode
  6. {
  7. 	  SLTDataType data;
  8. 	  struct SLTNode *next;
  9. }SLTNode;
  10.  
  11. //尾插
  12. void SListPushBack(SLTNode** pphead, SLTDataType x);
  13.  
  14. //头插
  15. void SListPushFront(SLTNode** pphead, SLTDataType x);
  16.  
  17. //头删
  18. void SListPopFront(SLTNode** pphead);
  19.  
  20. //尾删
  21. void SListPopBack(SLTNode** pphead);
  22.  
  23. //打印
  24. void SListprint(SLTNode* phead);
  25.  
  26. //查找数字
  27. SLTNode* SListFind(SLTNode* phead, SLTDataType x);
  28.  
  29. //在pos前面插入x
  30. void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
  31.  
  32. //在pos位置的删除
  33. void SListErase(SLTNode** pphead, SLTNode* pos);

2.SList.c:

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include"SList.h"
  3.  
  4. //申请新的节点
  5. SLTNode* BuySListNode(SLTDataType x)
  6. {
  7. 	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
  8. 	newnode->data = x;
  9. 	newnode->next = NULL;
  10. 	return newnode;
  11. }
  12. //尾插
  13. void SListPushBack(SLTNode** pphead, SLTDataType x)
  14. {
  15. 	SLTNode* newnode=BuySListNode(x);
  16. 	if (*pphead == NULL)
  17. 	{//这里一点定要判断一下，第一次尾插的时候就是NULL
  18. 	 //如果*pphead为空的时候，必须把它设置为新结点
  19. 		*pphead = newnode;
  20. 	}
  21. 	else
  22. 	{
  23. 		SLTNode* tail = *pphead;
  24. 		while (tail->next != NULL)//当链表结束的时候，最后一个next都是赋值为NULL
  25. 		{
  26. 			tail = tail->next;
  27. 		}
  28. 		tail->next = newnode;
  29. 	}
  30. }
  31.  
  32. //打印
  33. void SListprint(SLTNode* phead)
  34. {
  35. 	SLTNode* cur = phead;
  36. 	while (cur != NULL)
  37. 	{
  38. 		printf("%d->", cur->data);
  39. 		cur = cur->next;
  40. 	}
  41. 	printf("NULL");
  42. 	printf("\n");
  43. }
  44.  
  45. //头插
  46. void SListPushFront(SLTNode** pphead, SLTDataType x)
  47. {
  48. 	SLTNode* newnode = BuySListNode(x);
  49. 	newnode->next = *pphead;
  50. 	*pphead = newnode;
  51. }
  52.  
  53. //头删
  54. void SListPopFront(SLTNode** pphead)
  55. {
  56. 	SLTNode* next = (*pphead)->next;
  57. 	free(*pphead);
  58. 	*pphead = NULL;
  59. 	*pphead = next;
  60. }
  61.  
  62. //尾删
  63. void SListPopBack(SLTNode** pphead)
  64. {
  65. 	SLTNode* tail = *pphead;
  66. 	SLTNode* prev = NULL;
  67. 	//1.链表为空链表的时候
  68. 	if (*pphead == NULL)
  69. 	{
  70. 		return;
  71. 	}
  72. 	//2.链表只有一个节点的时候
  73. 	else if ((*pphead)->next == NULL)
  74. 	{
  75. 		free(*pphead);
  76. 		*pphead = NULL;
  77. 	}
  78. 	//3.链表有两个及两个以上的节点时
  79. 	else
  80. 	{
  81. 		while (tail->next != NULL)
  82. 		{
  83. 			prev = tail;
  84. 			tail = tail->next;
  85. 		}
  86. 		free(tail);
  87. 		prev->next = NULL;
  88. 	}
  89. }
  90.  
  91. //查找数字
  92. SLTNode* SListFind(SLTNode* phead, SLTDataType x)
  93. {
  94. 	SLTNode* cur = phead;
  95. 	while (cur)
  96. 	{
  97. 		if (cur->data == x)
  98. 		{
  99. 			return cur;
  100. 		}
  101. 		cur = cur->next;
  102. 	}
  103. 	return NULL;
  104. }
  105.  
  106. //在pos前面插入x
  107. void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
  108. {
  109. 	if (pos == *pphead)
  110. 	{
  111. 		SListPushFront(pphead, x);
  112. 	}
  113. 	else
  114. 	{
  115. 		SLTNode* newnode = BuySListNode(x);
  116. 		SLTNode* prev = *pphead;
  117. 		while (prev->next != pos)
  118. 		{
  119. 			prev = prev->next;
  120. 		}
  121. 		prev->next = newnode;
  122. 		newnode->next = pos;
  123. 	}
  124. }
  125. //在pos位置的值删除
  126.  void SListErase(SLTNode** pphead, SLTNode* pos)
  127. {
  128. 	if (*pphead == pos)
  129. 	{
  130. 		SListPopFront(pphead);
  131. 	}
  132. 	else
  133. 	{
  134. 		SLTNode* prev = *pphead;
  135. 		while (prev->next != pos)
  136. 		{
  137. 			prev = prev->next;
  138. 		}
  139. 		prev->next = pos->next;
  140. 		free(pos);
  141. 	}
  142. }

3.test.c:

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include"SList.h"
  3. SLTNode* plist = NULL;
  4. void SListtest1()
  5. {
  6. 	//尾插
  7. 	printf("尾插的值为:\n");
  8. 	SListPushBack(&plist, 1);
  9. 	SListPushBack(&plist, 2);
  10. 	SListPushBack(&plist, 3);
  11. 	SListPushBack(&plist, 4);
  12. 	SListprint(plist);
  13.  
  14. 	printf("头插之后为:\n");
  15. 	SListPushFront(&plist, 0);
  16. 	SListPushFront(&plist, 10);
  17. 	SListprint(plist);
  18. 	//头删
  19. 	printf("头删之后为：\n");
  20. 	SListPopFront(&plist);
  21. 	SListPopFront(&plist);
  22. 	SListprint(plist);
  23.  
  24. 	//尾删
  25. 	printf("尾删之后为：\n");
  26. 	SListPopBack(&plist);
  27. 	SListPopBack(&plist);
  28. 	SListprint(plist);
  29. }
  30. void SListtest2()
  31. {
  32. 	printf("尾插的值为:\n");
  33. 	SListPushBack(&plist, 1);
  34. 	SListPushBack(&plist, 2);
  35. 	SListPushBack(&plist, 3);
  36. 	SListPushBack(&plist, 4);
  37. 	SListprint(plist);
  38.  
  39. 	printf("头插之后为:\n");
  40. 	SListPushFront(&plist, 0);
  41. 	SListPushFront(&plist, 10);
  42. 	SListPushFront(&plist, 20);
  43. 	SListprint(plist);
  44.  
  45. 	printf("尾删之后为:\n");
  46. 	SListPopBack(&plist);
  47. 	SListPopBack(&plist);
  48. 	SListprint(plist);
  49. 	printf("\n");
  50.  
  51. 	printf("删除pos位置的值之后为:\n");
  52. 	SLTNode* pos = SListFind(plist, 2);
  53. 	if (pos)
  54. 	{
  55. 		SListErase(&plist, pos);
  56. 	}
  57. 	SListprint(plist);
  58.  
  59. 	printf("在pos位置前面插入数字后为：\n");
  60. 	pos = SListFind(plist, 1);
  61. 	if (pos)
  62. 	{
  63. 		SListInsert(&plist, pos, 10);
  64. 	}
  65. 	SListprint(plist);
  66. }
  67. int main()
  68. {
  69. 	//SListtest1();
  70. 	SListtest2();
  71.  
  72. 	return 0;
  73. }

总结:这就是单链表的全部内容，总之实现起来是不复杂的，主要还是靠自己理解，自己动手敲代码才行。

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

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

  

闽ICP备14008679号