devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构 | 单链表的基本实现_数据结构单链表基本操作的实现

作者：凡人多烦事01 | 2024-04-22 21:15:16

赞

踩

数据结构单链表基本操作的实现

学习教材：《数据结构——从概念到C++实现》
分类专栏：数据结构与算法(C++)

目录

前言

全文

1 链表概述

2 单链表的基本实现

2.1 建立只有头结点的空链表

2.2 建立指定长度的链表

2.3 析构函数

2.4 求单链表长度

2.5 按位查找元素

2.6 按值查找元素，返回元素序号

2.7 插入操作

2.8 删除操作

2.9 判空操作

2.10 遍历操作

全部代码

前言

        最近刚在学习《数据结构与算法》，单纯地跟课、看书觉得并不能很好的掌握好这些知识点，所以决定尝试将学习的知识点归纳总结，也将其进行代码实现，强化对知识点的理解。即作为笔记、实践，又作为我的思路分享。因为初学，难免有不正确、不恰当之处，敬请指正！

全文

1 单链表概述

        单链表（singly linked list）是用一组任意的存储单元存放线性表的元素，这组存储单元可以连续也可以不连续，甚至可以零散分布在内存中的任意位置。

        结点（node）是存放了数据元素和其后续元素所在的地址信息的存储映像。其中。data为数据域，存放数据元素；next为指针域，存放该结点的后继结点的地址。

        单链表通过每个结点的指针域将线性表的数据元素按照其逻辑次序链接在一起，由于每个结点只有一个指针域，故称为单链表。

2 单链表的基本实现

        先定义单链表的结点结构，包括数据域和指针域。

  1. template<typename DataType>
  2. struct Node
  3. {
  4. 	// 数据域
  5. 	DataType data;
  6. 	// 指针域
  7. 	Node<DataType>* next;
  8. };

        定义单链表类，其中成员变量 first 表示单链表的头指针，成员函数实现线性表的基本操作。

  1. template<typename DataType>
  2. class LinkList
  3. {
  4. public:
  5. 	// 建立只有头节点的空链表
  6. 	LinkList(); 
  7. 	// 建立n个元素的单链表
  8. 	LinkList(DataType a[], int n); 
  9. 	// 析构函数
  10. 	~LinkList() {};
  11. 	// 求单链表长度
  12. 	int Length();
  13. 	// 按位查找元素
  14. 	DataType Get(int i);
  15. 	// 按值查找元素，返回元素序号
  16. 	int Locate(DataType x);
  17. 	// 插入操作，在第i个位置插入值为x的元素
  18. 	void Insert(int i, DataType x);
  19. 	// 删除操作，删除第i个元素
  20. 	DataType Delect(int i);
  21. 	// 判断是否为空表
  22. 	int Empty();
  23. 	// 遍历单链+表进行打印
  24. 	void printList(); 
  25.  
  26. private:
  27. 	Node<DataType>* first; // 头指针
  28. };

2.1 建立只有头结点的空链表

        初始化单链表就是生成只有头结点的空单链表。

  1. // 建立只有头节点的空链表
  2. template<typename DataType>
  3. LinkList<DataType>::LinkList()
  4. {
  5. 	first = new Node<DataType>;
  6. 	first->next = nullptr;
  7. }

2.2 建立指定长度的链表

        本文中，选择采用头插法建立指定长度的链表。基本思想时将每次新申请的结点插在头结点的后面。

  1. // 建立n个元素的单链表
  2. template<typename DataType>
  3. LinkList<DataType>::LinkList(DataType a[], int n)
  4. {
  5. 	for (int i = 0; i < n; i++)
  6. 	{
  7. 		first = new Node<DataType>;
  8. 		first->next = nullptr;
  9. 		for (int i = 0; i < n; i++)
  10. 		{
  11. 			Node<DataType>* s = nullptr;
  12. 			s = new Node<DataType>;
  13. 			s->data = a[i];
  14. 			s->next = first->next;
  15. 			first->next = s;
  16. 		}
  17. 	}
  18. }

2.3 析构函数

        单链表是动态存储分配，单链表的结点实在程序运行中动态申请的，因此在单链表变量退出作用域之前，要释放单链表的存储空间。

  1. // 析构函数
  2. template<typename DataType>
  3. LinkList<DataType>::~LinkList()
  4. {
  5. 	Node<DataType>* p = first;
  6. 	while (first != nullptr)
  7. 	{
  8. 		first = first->next;
  9. 		delete p;
  10. 		p = first;
  11. 	}
  12. }

2.4 求单链表长度

        由于单链表类定义中没有存储线性表的长度，因此不能直接获得线性表的长度，使用遍历的方法来求其长度，设置工作指针p依次指向各个节点，当指针 p 指向一个结点时，累加器 count 加1，一直持续到最后一个结点，最后输出累加器 count 的值。

  1. // 求单链表长度
  2. template<typename DataType>
  3. int LinkList<DataType>::Length()
  4. {
  5. 	// 工作指针初始化
  6. 	Node<DataType>* p = first->next; 
  7. 	// 累加器初始化，算出链表长度
  8. 	int count = 0;
  9. 	while (p != nullptr)
  10. 	{
  11. 		p = p->next;
  12. 		count++;
  13. 	}
  14. 	return count;
  15. }

2.5 按位查找元素

        单链表是随机存储结构，不能直接跟据访问结点的序号来获取数据，只能从头指针出发顺 next 域逐个结点往下搜素。设置工作指针p，当指针p指向某结点判断为第 i 个结点时，查找成功，输出数据元素。若 i 超出链表长度，则查找失败。

  1. // 按位查找元素
  2. template<typename DataType>
  3. DataType LinkList<DataType>::Get(int i)
  4. {
  5. 	// 工作指针初始化
  6. 	Node<DataType>* p = first->next;
  7. 	int count = 1;
  8. 	while (p != nullptr && count < i)
  9. 	{
  10. 		p = p->next;
  11. 		count++;
  12. 	}
  13. 	if (p == nullptr) throw"查找位置错误";
  14. 	else return p->data;
  15. }

2.6 按值查找元素，返回元素序号

        在单链表中按值查找操作，需要对单链表中的元素依次进行比较。如果查找成功，返回元素的序号，否则返回0表示失败。

  1. // 按值查找元素，返回元素序号
  2. template<typename DataType>
  3. int LinkList<DataType>::Locate(DataType x)
  4. {
  5. 	// 工作指针初始化
  6. 	Node<DataType>* p = first->next;
  7. 	int count = 1;
  8. 	while (p != nullptr)
  9. 	{
  10. 		if (p->data == x)
  11. 			return count; // 查找成功返回序号 
  12. 		p = p->next;
  13. 		count++;
  14. 	}
  15. 	return 0; // 退出循环，表明查找失败
  16. }

2.7 插入操作

        插入操作是将值为 x 的新结点插入到链表的第 i 个位置。需要先扫描单链表，找到原来第 i-1 个结点，然后生成一个新的结点s，将结点 s 的指针域指向原来第 i 个结点，在数据域中存储 x ，最后将结点 s 的地址信息存储到第 i-1 个结点的指针域中。 

  1. // 插入操作，在第i个位置插入值为x的元素
  2. template<typename DataType>
  3. void LinkList<DataType>::Insert(int i, DataType x)
  4. {
  5. 	// 工作指针初始化
  6. 	Node<DataType>* p = first->next, * s = nullptr;
  7. 	int count = 0;
  8. 	while (p != nullptr && count < i-1)
  9. 	{
  10. 		p = p->next;
  11. 		count++;
  12. 	}
  13. 	if (p == nullptr) throw"插入位置错误！";
  14. 	else
  15. 	{
  16. 		s = new Node<DataType>;
  17. 		s->data = x;
  18. 		s->next = p->next;
  19. 		p->next = s;
  20. 	}
  21. }

2.8 删除操作

        删除操作是将第 i 个结点删去。需要找到第 i+1 个结点的存储地址，存储到第 i-1 个结点的指针域中，把第 i 个结点从恋上摘下，并通过 delete 释放其存储空间。

  1. // 删除操作，删除第i个元素
  2. template<typename DataType>
  3. DataType LinkList<DataType>::Delect(int i)
  4. {
  5. 	DataType x;
  6. 	// 工作指针初始化
  7. 	Node<DataType>* p = first->next, * s = nullptr;
  8. 	int count = 0;
  9. 	while (p != nullptr && count < i-1)
  10. 	{
  11. 		p = p->next;
  12. 		count++;
  13. 	}
  14. 	if (p == nullptr || p->next = nullptr ) throw"删除位置错误！";
  15. 	else
  16. 	{
  17. 		s = p->next;
  18. 		x = s->data;
  19. 		p->next = s->next;
  20. 		delete s;
  21. 		return x;
  22. 	}
  23. }

2.9 判空操作

        判空操作只需要判断单链表是否只有头结点，即 first->next 是否为空指针。

  1. // 判断是否为空表
  2. template<typename DataType>
  3. int LinkList<DataType>::Empty()
  4. {
  5. 	if (first->next == nullptr)
  6. 	{
  7. 		return 0;
  8. 	}
  9. 	else return 1;
  10. }

2.10 遍历操作

        遍历操作是指按序号依次访问单链表中所有的结点。可以设置一个工作指针p依次指向各个节点，当指针p指向某结点时，输出该结点的数据域。

  1. // 遍历单链+表进行打印
  2. template<typename DataType>
  3. void LinkList<DataType>::printList()
  4. {
  5. 	Node<DataType>* p = first->next;
  6. 	while (p != nullptr)
  7. 	{
  8. 		cout << p->data << " ";
  9. 		p = p->next;
  10. 	}
  11. }

全部代码

  1. #include<iostream>
  2. #include<string>
  3. using namespace std;
  4.  
  5. template<typename DataType>
  6. struct Node
  7. {
  8. 	// 数据域
  9. 	DataType data;
  10. 	// 指针域
  11. 	Node<DataType>* next;
  12. };
  13.  
  14. template<typename DataType>
  15. class LinkList
  16. {
  17. public:
  18. 	// 建立只有头节点的空链表
  19. 	LinkList(); 
  20. 	// 建立n个元素的单链表
  21. 	LinkList(DataType a[], int n); 
  22. 	// 析构函数
  23. 	~LinkList();
  24. 	// 求单链表长度
  25. 	int Length();
  26. 	// 按位查找元素
  27. 	DataType Get(int i);
  28. 	// 按值查找元素，返回元素序号
  29. 	int Locate(DataType x);
  30. 	// 插入操作，在第i个位置插入值为x的元素
  31. 	void Insert(int i, DataType x);
  32. 	// 删除操作，删除第i个元素
  33. 	DataType Delect(int i);
  34. 	// 判断是否为空表
  35. 	int Empty();
  36. 	// 遍历单链+表进行打印
  37. 	void printList(); 
  38.  
  39. private:
  40. 	Node<DataType>* first; // 头指针
  41. };
  42.  
  43. // 建立只有头节点的空链表
  44. template<typename DataType>
  45. LinkList<DataType>::LinkList()
  46. {
  47. 	first = new Node<DataType>;
  48. 	first->next = nullptr;
  49. }
  50.  
  51. // 建立n个元素的单链表
  52. template<typename DataType>
  53. LinkList<DataType>::LinkList(DataType a[], int n)
  54. {
  55. 	for (int i = 0; i < n; i++)
  56. 	{
  57. 		first = new Node<DataType>;
  58. 		first->next = nullptr;
  59. 		for (int i = 0; i < n; i++)
  60. 		{
  61. 			Node<DataType>* s = nullptr;
  62. 			s = new Node<DataType>;
  63. 			s->data = a[i];
  64. 			s->next = first->next;
  65. 			first->next = s;
  66. 		}
  67. 	}
  68. }
  69.  
  70. // 析构函数
  71. template<typename DataType>
  72. LinkList<DataType>::~LinkList()
  73. {
  74. 	Node<DataType>* p = first;
  75. 	while (first != nullptr)
  76. 	{
  77. 		first = first->next;
  78. 		delete p;
  79. 		p = first;
  80. 	}
  81. }
  82.  
  83. // 求单链表长度
  84. template<typename DataType>
  85. int LinkList<DataType>::Length()
  86. {
  87. 	// 工作指针初始化
  88. 	Node<DataType>* p = first->next; 
  89. 	// 累加器初始化，算出链表长度
  90. 	int count = 0;
  91. 	while (p != nullptr)
  92. 	{
  93. 		p = p->next;
  94. 		count++;
  95. 	}
  96. 	return count;
  97. }
  98.  
  99. // 按位查找元素
  100. template<typename DataType>
  101. DataType LinkList<DataType>::Get(int i)
  102. {
  103. 	// 工作指针初始化
  104. 	Node<DataType>* p = first->next;
  105. 	int count = 1;
  106. 	while (p != nullptr && count < i)
  107. 	{
  108. 		p = p->next;
  109. 		count++;
  110. 	}
  111. 	if (p == nullptr) throw"查找位置错误";
  112. 	else return p->data;
  113. }
  114.  
  115. // 插入操作，在第i个位置插入值为x的元素
  116. template<typename DataType>
  117. void LinkList<DataType>::Insert(int i, DataType x)
  118. {
  119. 	// 工作指针初始化
  120. 	Node<DataType>* p = first->next, * s = nullptr;
  121. 	int count = 0;
  122. 	while (p != nullptr && count < i-1)
  123. 	{
  124. 		p = p->next;
  125. 		count++;
  126. 	}
  127. 	if (p == nullptr) throw"插入位置错误！";
  128. 	else
  129. 	{
  130. 		s = new Node<DataType>;
  131. 		s->data = x;
  132. 		s->next = p->next;
  133. 		p->next = s;
  134. 	}
  135. }
  136.  
  137. // 按值查找元素，返回元素序号
  138. template<typename DataType>
  139. int LinkList<DataType>::Locate(DataType x)
  140. {
  141. 	// 工作指针初始化
  142. 	Node<DataType>* p = first->next;
  143. 	int count = 1;
  144. 	while (p != nullptr)
  145. 	{
  146. 		if (p->data == x)
  147. 			return count; // 查找成功返回序号 
  148. 		p = p->next;
  149. 		count++;
  150. 	}
  151. 	return 0; // 退出循环，表明查找失败
  152. }
  153.  
  154. // 删除操作，删除第i个元素
  155. template<typename DataType>
  156. DataType LinkList<DataType>::Delect(int i)
  157. {
  158. 	DataType x;
  159. 	// 工作指针初始化
  160. 	Node<DataType>* p = first->next, * s = nullptr;
  161. 	int count = 0;
  162. 	while (p != nullptr && count < (i-1))
  163. 	{
  164. 		p = p->next;
  165. 		count++;
  166. 	}
  167. 	if (p == nullptr || p->next == nullptr ) throw"删除位置错误！";
  168. 	else
  169. 	{
  170. 		s = p->next;
  171. 		x = s->data;
  172. 		p->next = s->next;
  173. 		delete s;
  174. 		return x;
  175. 	}
  176. }
  177.  
  178. // 判断是否为空表
  179. template<typename DataType>
  180. int LinkList<DataType>::Empty()
  181. {
  182. 	if (first->next == nullptr)
  183. 	{
  184. 		return 0;
  185. 	}
  186. 	else return 1;
  187. }
  188.  
  189. // 遍历单链+表进行打印
  190. template<typename DataType>
  191. void LinkList<DataType>::printList()
  192. {
  193. 	Node<DataType>* p = first->next;
  194. 	while (p != nullptr)
  195. 	{
  196. 		cout << p->data << " ";
  197. 		p = p->next;
  198. 	}
  199. 	cout << endl;
  200. }
  201.  
  202. // 测试代码
  203. //void test()
  204. //{
  205. //	int r[5] = { 2,4,3,5,6 };
  206. //	int x = 0, i = 0;
  207. //	LinkList<int> l(r, 5);
  208. //	cout << "当前链表的数据为：";
  209. //	l.printList();
  210. //
  211. //	l.Insert(2, 8);
  212. //	cout << "插入后链表的数据为：";
  213. //	l.printList();
  214. //
  215. //	cout << "当前链表的长度为： " << l.Length()<<endl;
  216. //	cout << "请输入查找的元素值： ";
  217. //	cin >> x;
  218. //	i = l.Locate(x);
  219. //	cout << x << "元素的位置为：" << i << endl;
  220. //
  221. //	cout << "请输入要删除的元素序号：" << endl;
  222. //	cin >> i;
  223. //	x = l.Delect(i);
  224. //	cout << "删除的元素值为： " << x << endl;
  225. //	cout << "删除后链表的数据为：";
  226. //	l.printList();
  227. //}
  228.  
  229. int main()
  230. {
  231. 	//test();  测试代码
  232. 	return 0;
  233. }

初学数据结构与算法，若有不正确之处，敬请指正啦~

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

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

  

闽ICP备14008679号