NET 数据结构-单链表
2024-06-16 10:35:24
概念介绍：
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。
链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据
由图可知：
- 链表在进行添加/删除时，只需要修改 当前节点和相邻节点 的next，更新效率高
- 遍历数据，需要根据节点按顺序访问，导致查询速度慢，时间复杂度为O(n)
- 每个节点中都保存了下一个节点的指针【Next，最后一个节点的next为null】，所以长度是动态变化的，且不是连续内存空间
相关代码：
MyLinkedListNode:自定义链表节点类
1 /// <summary>
2 /// 自定义链表节点类： 单链表
3 /// </summary>
4 public class MyLinkedListNode<T>
5 {
6 /// <summary>
7 /// 当前节点
8 /// </summary>
9 public T Node { get; set; }
10
11 /// <summary>
12 /// 下一个节点
13 /// </summary>
14 public MyLinkedListNode<T> Next { get; set; }
15
16 /// <summary>
17 /// 构造函数： 无参构造函数
18 /// </summary>
19 /// <param name="Node"></param>
20 public MyLinkedListNode()
21 {
22 this.Node = default;
23 this.Next = null;
24 }
25
26 /// <summary>
27 /// 构造函数： 指定当前节点，常用于 新增根节点和最后一个节点
28 /// </summary>
29 /// <param name="node"></param>
30 public MyLinkedListNode(T node)
31 {
32 this.Node = node;
33 this.Next = null;
34 }
35
36 /// <summary>
37 /// 构造函数： 指定当前节点和下一节点，常用于 新增内部节点/确定下一节点 的情况
38 /// </summary>
39 /// <param name="next"></param>
40 /// <param name="Next"></param>
41 public MyLinkedListNode(T node, MyLinkedListNode<T> next)
42 {
43 this.Node = node;
44 this.Next = next;
45 }
46 }View Code
MyLinkedList:自定义链表
1 /// <summary>
2 /// 自定义链表
3 /// 功能：
4 /// 1.添加： 添加到集合最后面
5 /// 2.添加： 添加到集合最前面
6 /// 3.添加： 添加索引后面
7 /// 4.添加： 添加索引前面
8 /// 5.删除： 删除T
9 /// 6.删除： 删除指定索引
10 /// 7.删除： 删除第一个
11 /// 8.删除： 删除最后一个
12 /// 9.删除： 删除所有
13 /// </summary>
14 public class MyLinkedList<T>
15 {
16 /// <summary>
17 /// 存储链表集合-根节点：
18 /// 框架自带了双向链表 System.Collections.Generic.LinkedList，链表集合保存在 MyLinkedListNode 中
19 /// 考虑到存在clear方法，链表默认值为null更方便
20 /// </summary>
21 private MyLinkedListNode<T> _rootNode = null; // { get; set; }
22
23 /// <summary>
24 /// 索引索引器，从0开始，根据索引返回指定索引节点信息
25 /// </summary>
26 /// <param name="index"></param>
27 /// <returns></returns>
28 public T this[int index]
29 {
30 get
31 {
32 var node = GetNodeAt(index).Node;
33 Console.WriteLine($"this[int {index}] = {node}\r\n");
34 return node;
35 }
36 }
37
38 #region 查询方法
39
40 /// <summary>
41 /// 根据索引返回指定索引节点信息
42 /// </summary>
43 /// <param name="index">索引，从0开始</param>
44 /// <returns></returns>
45 private MyLinkedListNode<T> GetNodeAt(int index) => GetNodeTupleAt(index)?.Item1;
46
47 /// <summary>
48 /// 根据索引返回指定索引：节点元组
49 /// </summary>
50 /// <param name="index">索引，从0开始</param>
51 /// <returns>item1:当前节点;item2:上一节点;item3:下一节点;</returns>
52 private Tuple<MyLinkedListNode<T>, MyLinkedListNode<T>, MyLinkedListNode<T>> GetNodeTupleAt(int index)
53 {
54 if (index < 0) return null;
55 if (_rootNode == null) throw new Exception("自定义链表为空！");
56
57 var num = 0;
58 // 当前节点
59 MyLinkedListNode<T> currentNode = _rootNode;
60 // 上一节点
61 MyLinkedListNode<T> prevNode = _rootNode;
62 // while循环会在 currentNode == 倒数第二个节点时就会停止循环，所以while后面需要再做一次判断
63 while (currentNode.Next != null)
64 {
65 // 如果当前索引 和 查找索引相同，则返回担负起节点
66 if (num == index) return GetValidNodeTuple(index, currentNode, prevNode);
67 // 重置：上一节点
68 prevNode = currentNode;
69 // 重置：当前节点
70 currentNode = currentNode.Next;
71 num++;
72 }
73 if (num < index) throw new Exception("索引超过链表长度！");
74 return num == index ? GetValidNodeTuple(index, currentNode, prevNode) : null;
75 }
76
77 /// <summary>
78 /// 获取有效的节点元组
79 /// </summary>
80 /// <param name="index">索引</param>
81 /// <param name="currentNode">当前节点</param>
82 /// <param name="prevNode">上一节点【如果索引 == 0 ？ null ：上一节点 】</param>
83 /// <returns>item1:当前节点;item2:上一节点;item3:下一节点;</returns>
84 private Tuple<MyLinkedListNode<T>, MyLinkedListNode<T>, MyLinkedListNode<T>> GetValidNodeTuple(int index, MyLinkedListNode<T> currentNode, MyLinkedListNode<T> prevNode)
85 {
86 return new Tuple<MyLinkedListNode<T>, MyLinkedListNode<T>, MyLinkedListNode<T>>(currentNode, index == 0 ? null : prevNode, currentNode.Next);
87 }
88
89 #endregion
90
91 #region 添加方法
92
93 /// <summary>
94 /// 1.添加： 添加到集合最后面
95 /// </summary>
96 /// <param name="item"></param>
97 public void Append(T item)
98 {
99 MyLinkedListNode<T> node = new MyLinkedListNode<T>(item);
100 // 如果链表集合为空，则讲当前 元素当作跟节点
101 if (_rootNode == null)
102 {
103 _rootNode = node;
104 return;
105 }
106
107 // 循环得到最末节点
108 MyLinkedListNode<T> currentNode = _rootNode;
109 while (currentNode.Next != null) currentNode = currentNode.Next;
110
111 // 添加到集合最后面
112 currentNode.Next = node;
113 }
114
115 /// <summary>
116 /// 2.添加： 添加到集合最前面
117 /// </summary>
118 /// <param name="item"></param>
119 public void AddFirst(T item)
120 {
121 MyLinkedListNode<T> node = new MyLinkedListNode<T>(item);
122 // 如果链表集合为空，则讲当前 元素当作跟节点
123 if (_rootNode == null)
124 {
125 _rootNode = node;
126 return;
127 }
128
129 _rootNode = new MyLinkedListNode<T>(item, _rootNode);
130
131 // 显示链表中的所有数据
132 Console.Write($"AddFirst({item})\t");
133 Show();
134 }
135
136 /// <summary>
137 /// 3.添加： 在索引后面添加
138 /// 3.1.获取到当前索引的节点
139 /// 3.2.根据item创建新节点,把 当前节点的 下一节点指给 新节点的下一节点
140 /// 3.3.把新节点当作当前节点的下一节点
141 /// </summary>
142 /// <param name="index"></param>
143 /// <param name="item"></param>
144 public void AddAtAfter(int index, T item)
145 {
146 MyLinkedListNode<T> node = new MyLinkedListNode<T>(item);
147 // 如果链表集合为空，则讲当前 元素当作跟节点
148 if (_rootNode == null)
149 {
150 _rootNode = node;
151 return;
152 }
153 // 3.1.获取到当前索引的节点
154 var currentNode = GetNodeAt(index);
155 // 如果链表集合为空，则讲当前 元素当作跟节点
156 if (currentNode == null)
157 {
158 _rootNode = node;
159 return;
160 }
161
162 // 3.2.根据item创建新节点
163 var newNode = new MyLinkedListNode<T>(item, currentNode.Next);
164
165 // 3.3.把新节点当作当前节点的下一节点
166 currentNode.Next = newNode;
167
168 // 显示链表中的所有数据
169 Console.Write($"AddAtAfter(int {index},T {item})\t");
170 Show();
171 }
172
173 /// <summary>
174 /// 4.添加： 在索引前面添加
175 /// 4.1.获取到 当前索引 和 上一索引 的节点
176 /// 4.2.根据item创建新节点，把当前节点当作新节点的下一节点
177 /// 4.3.把新节点当作上一节点的下一节点
178 /// </summary>
179 /// <param name="index"></param>
180 /// <param name="item"></param>
181 public void AddAtBefore(int index, T item)
182 {
183 var nodeTuple = GetNodeTupleAt(index);
184 if (nodeTuple == null) throw new Exception("索引超过链表长度！");
185
186 // 4.1.获取到 当前索引 和 上一索引 的节点
187 var currentNode = nodeTuple.Item1;
188 var prevtNode = nodeTuple.Item2;
189
190 // 4.2.根据item创建新节点，把当前节点当作新节点的下一节点
191 var newNode = new MyLinkedListNode<T>(item, currentNode);
192
193 // 4.3.把新节点当作上一节点的下一节点:如果索引是0，则新节点作为链接根节点
194 if (index == 0) _rootNode = newNode;
195 else prevtNode.Next = newNode;
196
197 // 显示链表中的所有数据
198 Console.Write($"AddAtBefore(int {index},T {item})\t");
199 Show();
200 }
201
202 #endregion
203
204 #region 删除方法
205
206
207 /// <summary>
208 /// 5.删除： 删除T
209 /// 5.1.得到 当前节点/上一节点/下一节点
210 /// 5.2.把 上一节点的下一节点 更新为 下一节点
211 /// </summary>
212 /// <param name="item"></param>
213 public void Remove(T item)
214 {
215 if (_rootNode == null) return;
216 // 当前节点
217 var currentNode = _rootNode;
218 // 上一节点
219 MyLinkedListNode<T> prevNode = null;
220 while (currentNode.Next != null)
221 {
222 if (currentNode.Node.Equals(item))
223 {
224 // 根据 当前节点 的 上一节点和下一节点 删除 当前节点
225 Remove(prevNode, currentNode.Next);
226
227 // 显示链表中的所有数据
228 Console.Write($"Remove({item})\t");
229 Show();
230 return;
231 }
232 // 重置 上一节点 和 当前节点
233 prevNode = currentNode;
234 currentNode = currentNode.Next;
235 }
236 // 如果需要删除的是最后一个节点，则while循环在 currentNode == 倒数第二个节点时就会停止循环
237 Remove(prevNode, null);
238
239 // 显示链表中的所有数据
240 Console.Write($"Remove({item})\t");
241 Show();
242 }
243
244 /// <summary>
245 /// 根据 当前节点 的 上一节点和下一节点 删除 当前节点：把上一节点的next 指向 下一节点
246 /// </summary>
247 /// <param name="prevNode"></param>
248 /// <param name="nextNode"></param>
249 private void Remove(MyLinkedListNode<T> prevNode, MyLinkedListNode<T> nextNode)
250 {
251 if (prevNode == null) _rootNode = nextNode;
252 else prevNode.Next = nextNode;
253 }
254
255 /// <summary>
256 /// 6.删除： 删除指定索引
257 /// 6.1.得到 当前/上一/下一节点
258 /// 6.2.把当前节点的下一节点 更新为 下一节点
259 /// </summary>
260 /// <param name="index"></param>
261 public void RemoveAt(int index)
262 {
263 var nodeTuple = GetNodeTupleAt(index);
264
265 // 上一节点
266 var prevNode = nodeTuple.Item2;
267 // 判断上一节点是不是null ? 当前节点为根节点，需要把下一节点更新为更节点
268 if (prevNode == null) _rootNode = nodeTuple.Item3;
269 else prevNode.Next = nodeTuple.Item3;
270
271
272 // 显示链表中的所有数据
273 Console.Write($"RemoveAt({index})\t");
274 Show();
275 }
276
277 /// <summary>
278 /// 7.删除： 删除第一个
279 /// </summary>
280 public void RemoveFirst()
281 {
282 if (_rootNode == null) return;
283 _rootNode = _rootNode.Next;
284
285 // 显示链表中的所有数据
286 Console.Write($"RemoveFirst()\t");
287 Show();
288 }
289
290 /// <summary>
291 /// 8.删除： 删除最后一个
292 /// </summary>
293 public void RemoveLast()
294 {
295 if (_rootNode == null) return;
296 // 如果链表只存在根节点，则把根节点删除
297 if (_rootNode.Next == null)
298 {
299 _rootNode = null;
300 return;
301 }
302 // while循环获得最后一个节点
303 var currentNode = _rootNode;
304 // 上一节点/倒数第二个节点
305 MyLinkedListNode<T> prevNode = null;
306 while (currentNode.Next != null)
307 {
308 prevNode = currentNode;
309 currentNode = currentNode.Next;
310 }
311 prevNode.Next = null;
312
313 // 显示链表中的所有数据
314 Console.Write($"RemoveLast()\t");
315 Show();
316 }
317
318 /// <summary>
319 /// 9.删除： 删除所有
320 /// </summary>
321 public void Clear()
322 {
323 _rootNode = null;
324
325 // 显示链表中的所有数据
326 Console.Write($"Clear()\t");
327 Show();
328 }
329
330 #endregion
331
332 /// <summary>
333 /// 显示链表中的所有数据
334 /// </summary>
335 public void Show()
336 {
337 if (_rootNode == null)
338 {
339 Console.WriteLine($"链表中的数据为空！\r\n");
340 return;
341 }
342 StringBuilder builder = new StringBuilder();
343
344 MyLinkedListNode<T> currentNode = _rootNode;
345 while (currentNode.Next != null)
346 {
347 builder.Append($"{currentNode.Node}\t");
348 currentNode = currentNode.Next;
349 }
350 // 最后一个节点next为null，不会进入while
351 builder.Append($"{currentNode.Node}\t");
352
353 Console.WriteLine($"链表中的数据为：\r\n{builder.ToString()}\r\n");
354 }
355 }View Code
测试代码：
1 /// <summary>
2 /// 测试单链表
3 /// </summary>
4 public static void RunLinkedList()
5 {
6 Console.WriteLine("======= 链表测试 Start =======");
7
8 MyLinkedList<string> myLinkedList = new MyLinkedList<string>();
9 myLinkedList.Append("张三");
10 myLinkedList.Append("李四");
11 myLinkedList.Append("王五");
12 myLinkedList.Append("六麻子");
13 myLinkedList.Append("田七");
14 myLinkedList.Show(); // 张三 李四 王五 六麻子 田七
15
16 // 异常测试
17 var a = myLinkedList[1]; // 张三
18 a = myLinkedList[3]; // 六麻子
19 //a = myLinkedList[11];
20
21 // 测试添加功能
22 myLinkedList.AddFirst("郭大爷"); // 郭大爷 张三 李四 王五 六麻子 田七
23 myLinkedList.AddAtAfter(0, "海大爷"); // 郭大爷 海大爷 张三 李四 王五 六麻子 田七
24 myLinkedList.AddAtBefore(0, "Robot"); // Robot 郭大爷 海大爷 张三 李四 王五 六麻子 田七
25 myLinkedList.AddAtBefore(2, "Robot"); // Robot 郭大爷 Robot 海大爷 张三 李四 王五 六麻子 田七
26 myLinkedList.AddAtBefore(4, "Robot"); // Robot 郭大爷 Robot 海大爷 Robot 张三 李四 王五 六麻子 田七
27
28 // 测试删除功能
29 myLinkedList.Remove("Robot"); // 郭大爷 Robot 海大爷 Robot 张三 李四 王五 六麻子 田七
30 myLinkedList.Remove("Robot"); // 郭大爷 海大爷 Robot 张三 李四 王五 六麻子 田七
31 myLinkedList.Remove("田七"); // 郭大爷 海大爷 Robot 张三 李四 王五 六麻子
32 myLinkedList.RemoveAt(0); // 海大爷 Robot 张三 李四 王五 六麻子
33 myLinkedList.RemoveAt(1); // 海大爷 张三 李四 王五 六麻子
34 myLinkedList.RemoveFirst(); // 张三 李四 王五 六麻子
35 myLinkedList.RemoveFirst(); // 李四 王五 六麻子
36 myLinkedList.RemoveLast(); // 李四 王五
37 myLinkedList.RemoveLast(); // 李四
38 myLinkedList.Clear(); // 链表中的数据为空！
39
40 Console.WriteLine("======= 链表测试 End =======");
41 }
NET 数据结构-单链表相关推荐
- 20175330 数据结构-单链表(选做）
要求 参见附件,补充MyList.java的内容,提交运行结果截图(全屏) 课下推送代码到码云 ``` public class MyList { public static void mai ...
- php链表和联表的区别,PHP_浅谈PHP链表数据结构(单链表)，链表：是一个有序的列表，但 - phpStudy...
浅谈PHP链表数据结构(单链表) 链表:是一个有序的列表,但是它在内存中是分散存储的,使用链表可以解决类似约瑟夫问题,排序问题,搜索问题,广义表 单向链表,双向链表,环形链表 PHP的底层是C,当一个 ...
- 数据结构——单链表的C++实现
数据结构--单链表的C++实现 \qquad单链表的创建.求长度.查找.插入和删除的C++实现. #include<iostream> using namespace std;//1.定义 ...
- php mysql 链表_浅谈PHP链表数据结构(单链表)
链表:是一个有序的列表,但是它在内存中是分散存储的,使用链表可以解决类似约瑟夫问题,排序问题,搜索问题,广义表 单向链表,双向链表,环形链表 PHP的底层是C,当一个程序运行时,内存分成五个区(堆区, ...
- python 单链表是否有回路_（Python3）数据结构--单链表之判断链表是否有环
前言 有Python基础 有数据结构单链表基础,没接触过的可以看下面链接 https://blog.csdn.net/sf9898/article/details/104946291 原理和实现 有一 ...
- 数据结构 —— 单链表（超详细图解 接口函数实现）
系列文章目录 数据结构 -- 顺序表 数据结构 -- 单链表 数据结构 -- 双向链表 数据结构 -- 队列 数据结构 -- 栈 数据结构 -- 堆 数据结构 -- 二叉树 数据结构 -- 八大排序 ...
- C语言数据结构单链表链表
数据结构–单链表 学习了顺序表,我们发现顺序表在向里面存放数据的时候很麻烦,比如我们要使用头插法存放一个数据到顺序表的时候,我们要将整个表都向后挪一位,这个操作就让人很难受.那么有没有一种结构可以让我 ...
- 数据结构——单链表（小白入门第二天）
一.什么是单链表? 定义:每个结点 除了存放数据元素外,还要存储指向下一个节点的指针: 优点:不要求大片连续空间,改变容量方便: 缺点:不可随机存取,要耗费一定空间存放指针 局限性:无法逆向检索 二. ...
- 数据结构-单链表基本操作（C语言实现）
参考书:王道考研数据结构 (此贴为博主学习408的笔记,因博主也是学习者,个人总结如有错误欢迎指正.如有侵权请告知,马上删除致歉) 单链表定义 单链表是线性表的链式存储,通过一组任意的存储单元来存 ...
- 数据结构 -- 单链表
快要放假了,实在是待不住了,论文也看不下去,也没啥其他的事做,就写写常用的数据结构吧,正好下个学期就要找工作了,也是方便以后自己使用这些数据结构,好吧,这里实现的数据结构没有太多的错误控制 ...
最新文章
- 位运算与组合搜索（二）
- jenkins+findbugs+checkstyle+PMD静态代码检查（二）
- 数据库MYSQL学习系列一
- 教育部计算机科学,关于批准计算机科学与技术专业教学改革与实践项目立项的通知...
- oracle .ctl 是什么文件_Oracle误删dual表怎么办？这里教你怎么恢复
- Bootstrap 3 移除输入框聚焦线 How to remove border (outline) around text/input boxes?
- Linux命令总结（之二）Find
- 【毕业设计】基于Java的五子棋游戏的设计(源代码+论文)
- uid_t gid_t等的定义
- 如何制作多语种发音词典？多语种发音词典的制作方法！
- Edge（chrome内核）浏览器Linux版本初体验
- Android 获取文件后缀名
- 教你语音如何转换成文字的？
- 看小伙是如何用python尽览我国植被覆盖率的沧海变化
- python初学一（字符串str的处理方式）
- Java实现背包问题之01背包（是否装满），完全背包
- 知乎热议！谷歌员工，在家办工要降薪25%？
- 大众点评woff反爬
- 金融行业容器平台落地路径：敏捷响应业务更迭 1
- STM32F407利用RT-thread上移植LWIP
热门文章
- Python使用pycrypto进行RSA长字符串加密
- 为你的项目搭建sentry并且通过企微推送
- mysql 双主 脑裂_MySQL高可用方案——双主
- echars省份地图（安徽地图地图加散点图）亮点展示
- vue+ echarts实现地图（中国地图）
- php写彩票中奖代码,php简单中奖算法(实例)
- 鼠标每隔几秒失去焦点，鼠标每隔几秒转圈，鼠标每隔几秒刷新
- 扇贝python离线_扇贝自动打卡Python脚本（Python3）
- bp神经网络分类器c语言,基于BP神经网络的隐写分析分类器设计
- DALLE·2（Hierarchical Text-Conditional Image Generation with CLIP Latents）