在编程领域，数据结构与算法向来都是提升编程能力的重点。而一般常见的数据结构是链表，栈，队列，树等。事实上C#也已经封装好了这些数据结构，在头文件 System.Collections.Generic 中，直接创建并调用其成员方法就行。不过我们学习当然要知其然，亦知其所以然。

本文实现的是链表中的单链表和双向链表，并且实现了一些基本方法

一. 定义一个链表接口 MyList

接口里声明了我们要实现的方法：

  1. 	interface MyList<T>
  2. 	{
  3. 		int GetLength();							//获取链表长度
  4. 		void Clear();								//清空链表
  5. 		bool IsEmpty();								//判断链表是否为空
  6. 		void Add(T item);							//在链表尾部添加新节点
  7. 		void AddPre(T item,int index);				//在指定节点前添加新节点
  8. 		void AddPost(T item,int index);				//在指定节点后添加新节点
  9. 		T Delete(int index);						//按索引删除节点
  10. 		T Delete(T item,bool isSecond = true);		//按内容删除节点，如果有多个内容相同点，则删除第一个
  11. 		T this[int index] { get; }					//实现下标访问
  12. 		T GetElem(int index);						//根据索引返回元素
  13. 		int GetPos(T item);							//根据元素返回索引地址
  14. 		void Print();								//打印
  15. 	}

二. 实现单链表

2.1 节点类

先定义一个单链表所用的节点类，Node。而且我们要实现泛型

先定义一个数据域和下一节点（“Next”），并进行封装，然后给出数个重载构造器。这一步比较简单，这里直接给出代码

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  7. namespace 线性表
  8. {
  9. 	/// <summary>
  10. 	/// 单向链表节点
  11. 	/// </summary>
  12. 	/// <typeparam name="T"></typeparam>
  13. 	class Node<T>
  14. 	{
  15. 		private T data;						//内容域
  16. 		private Node<T> next;				//下一节点
  18. 		public Node()
  19. 		{
  20. 			this.data = default(T);
  21. 			this.next = null;
  22. 		}
  24. 		public Node(T value)
  25. 		{
  26. 			this.data = value;
  27. 			this.next = null;
  28. 		}
  30. 		public Node(T value,Node<T> next)
  31. 		{
  32. 			this.data = value;
  33. 			this.next = next;
  34. 		}
  36. 		public T Data
  37. 		{
  38. 			get { return data; }
  39. 			set { data = value; }
  40. 		}
  42. 		public Node<T> Next
  43. 		{
  44. 			get { return next; }
  45. 			set { next = value; }
  46. 		}
  47. 	}
  48. }

2.2 链表类

创建一个链表类，命名为 LinkList 并继承 MyList。

​

先定义一个头结点，尾节点和一个 count；

​

其中，head 表示该链表的头部，不包含数据；

tail 表示尾节点，指向该链表最后一个节点，当链表中只有 head 时，tail 指向 head。定义 tail 会方便接下来的操作

count 用来表示该链表中除了 head 以外的节点个数

构造函数：

  1. 		/// <summary>
  2. 		/// 构造器
  3. 		/// </summary>
  4. 		public LinkList()
  5. 		{
  6. 			head = new Node<T>();
  7. 			tail = head;
  8. 			count = 0;
  9. 		}

在我们实现成员函数之前，先实现两个特别的方法，因为在许多的成员方法中都要做两个操作：

  • 判断索引 index 是否合法，即是否小于0或者大于当前链表的节点个数
  • 寻找到 index 所代表的节点

①. 判断索引是否合法，然后可以根据其返回的数值进行判断操作

​

②. 寻找节点。

​

定义这两个方法主要是它们的重复使用率高，所以把它们的代码抽出来。

相对于数组，链表的插入与删除更方便，而查找却更加费时，一般都是从头结点开始遍历链表，时间复杂度为 O(n) ，而跳跃链表则会对查询进行优化，当然这会在下一篇中详述。现在继续来实现成员方法。

1. 获取链表长度

​ 

 这个方法实际上是比较简单的，因为 count 会随着添加，删除等操作自动增减，所以直接返回 count 就相当于 链表长度。

需要注意的是，本文中的 count 是不计算空头结点的，即 head 不会计算入内

2. 清空链表

​

这里要注意对 tail 的操作，而 head.Next 原本所指的节点不再被引用后，会被GC自动回收

3. 判断链表是否为空

因为本文实现的链表是带空头结点的，所以这里认为，当除了头结点外没有别的节点时，则为空链表

​

4. 在链表尾部添加节点

在链表尾添加节点一般考虑两种情况：

  • 当前除了头结点没有别的节点，此时相当于创建第一个节点
  • 寻找到最后一个节点

对于带空头结点的链表来说，这两种情况有着一样的操作，只不过第一种情况要多做一步：让 head 指向新创建的节点

​

定义了 tail 节点省去了 遍历寻找最后节点的步骤，如果此时是空链表的话，tail 则指向 head

5. 在指定索引的前或后添加节点

这两个方法的思路实际上相差无几的

​

如图，当 index 为 F 时：

  • AddPost： ① 找到 F 节点 ②创建 NEW 节点；③ NEW 节点指向 G；④ F 指向 NEW 节点
  • AddPre   :  ① 找到 E 节点 ②创建 NEW 节点；③ NEW 节点指向 F ；④ E 指向 NEW 节点

 AddPre 相当于 index - 1 处的 AddPost；AddPost 相当于 index + 1 处的 AddPre（当然，这是在 index -1 与 index + 1 合法的情况下）

​

​

6. 两种删除节点方法

  • 按索引删除：找到索引所指节点，删除
  • 按元素删除：找元素所在的索引；当找不到该元素时表明链表中不存在应该删除的节点，不执行删除操作；当链表中存在多个相同的元素时，找到并删除第一个

​

两种删除方法操作都是相似的，只是搜索节点的方法不同，删除时要严格注意节点间指向的，即注意书写代码时的顺序

​

​

7. 实现下标访问

这是个比较有趣的实现。前文说过对比于数组，链表胜于增减，弱于访问。对链表实现下标式访问，虽然它的内核依然是遍历链表，然后返回节点，但在使用上会方便许多，如同使用数组一般。

​

8. 根据索引返回元素

这个和 GetNode 方法一致

​

9. 根据元素返回索引地址

​

这个方法也是比较简单的，只是需要注意的一点是：while循环条件中 && 号两端的条件不能调换位置。因为如果调换位置后，当链表遍历到最后一个节点仍没找到元素时，pstr 会被赋值下一节点（此时为NULL），然后循环继续执行，执行到 ！pstr.Data.Equals(item) 这一句时会报空指针，因为此时 pstr 就是空指针；还有因为这是泛型，所以判断两个值是否相等不能用 == 号，除非你重载 == 号。

10.打印链表

​

至此，所以的成员方法都实现了，先来测试一下。

1

.​

​

​

​

其它功能读者可以自行测试，完整代码：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  7. namespace 线性表
  8. {
  9. 	class LinkList<T> : MyList<T>
  10. 	{
  11. 		private Node<T> head;			//头结点
  12. 		private Node<T> tail;			//尾节点
  13. 		private int count;				//节点个数
  15. 		/// <summary>
  16. 		/// 构造器
  17. 		/// </summary>
  18. 		public LinkList()
  19. 		{
  20. 			head = new Node<T>();
  21. 			tail = head;
  22. 			count = 0;
  23. 		}
  25. 		/// <summary>
  26. 		/// 实现下标访问法
  27. 		/// </summary>
  28. 		/// <param name="index"></param>
  29. 		/// <returns></returns>
  30. 		public T this[int index]
  31. 		{
  32. 			get
  33. 			{
  34. 				int i = IsIndexVaild(index);
  35. 				if(i == -1) return default(T);
  37. 				int k = 0;
  38. 				Node<T> pstr = head;
  39. 				while (k++ < index )
  40. 				{
  41. 					pstr = pstr.Next;
  42. 				}
  44. 				return pstr.Data;
  46. 			}
  47. 		}
  49. 		/// <summary>
  50. 		/// 在链表最末端添加新节点
  51. 		/// </summary>
  52. 		/// <param name="item"></param>
  53. 		public void Add(T item)
  54. 		{
  55. 			Node<T> tailNode = new Node<T>(item);
  56. 			tail.Next = tailNode;
  57. 			tail = tailNode;
  58. 			if (count == 0) head.Next = tailNode;
  59. 			count++;
  60. 		}
  62. 		/// <summary>
  63. 		/// 在第 index 号元素后插入一个节点
  64. 		/// <param name="item"></param>
  65. 		/// <param name="index"></param>
  66. 		public void AddPost(T item, int index)
  67. 		{
  68. 			int i = IsIndexVaild(index);
  69. 			if (i == -1) return;
  71. 			//找到索引元素
  72. 			Node<T> pstr = GetNode(index);
  74. 			//链接新节点
  75. 			Node<T> node = new Node<T>(item);
  76. 			node.Next = pstr.Next;
  77. 			pstr.Next = node;
  78. 			if (index == count) tail = node;
  79. 			count++;
  80. 			pstr = null;
  81. 		}
  83. 		/// <summary>
  84. 		/// 在第 index 号元素前插入一个节点
  85. 		/// </summary>
  86. 		/// <param name="item"></param>
  87. 		/// <param name="index"></param>
  88. 		public void AddPre(T item, int index)
  89. 		{
  90. 			int i = IsIndexVaild(index);
  91. 			if (i == -1) return;
  93. 			//找到索引的前一位元素
  94. 			Node<T> pstr = GetNode(index - 1);
  96. 			//链接新节点
  97. 			Node<T> node = new Node<T>(item);
  98. 			node.Next = pstr.Next;
  99. 			pstr.Next = node;
  100. 			count++;
  101. 			pstr = null;
  102. 		}
  104. 		/// <summary>
  105. 		/// 清空链表
  106. 		/// </summary>
  107. 		public void Clear()
  108. 		{
  109. 			head.Next = null;
  110. 			tail = head;
  111. 		}
  113. 		/// <summary>
  114. 		/// 删除指定位置的元素
  115. 		/// </summary>
  116. 		/// <param name="index"></param>
  117. 		/// <returns></returns>
  118. 		public T Delete(int index)
  119. 		{
  120. 			int i = IsIndexVaild(index);
  121. 			if (i == -1) return default(T);
  123. 			//找到索引的前一位元素
  124. 			Node<T> pstr = GetNode(index - 1);
  126. 			if (pstr.Next == null) return default(T);
  128. 			Node<T> qstr = pstr.Next;
  129. 			pstr.Next = qstr.Next;
  130. 			T t = qstr.Data;
  131. 			pstr = null;
  132. 			qstr.Next = null;
  133. 			qstr = null;
  134. 			count--;
  135. 			return t;
  136. 		}
  138. 		/// <summary>
  139. 		/// 按内容删除
  140. 		/// </summary>
  141. 		/// <param name="item"></param>
  142. 		/// <param name="isSecond"></param>
  143. 		/// <returns></returns>
  144. 		public T Delete(T item,bool isSecond = true)
  145. 		{
  147. 			int k = GetPos(item);
  148. 			if (k == -1) return default(T);
  149. 			int i = 0;
  151. 			Node<T> pstr = head;
  152. 			while (i++ < k -1)
  153. 			{
  154. 				pstr = pstr.Next;
  155. 			}
  156. 			Node<T> qstr = pstr.Next;
  157. 			pstr.Next = qstr.Next;
  158. 			T t = qstr.Data;
  159. 			pstr = null;
  160. 			qstr.Next = null;
  161. 			qstr = null;
  162. 			count--;
  163. 			return t;
  164. 		}
  166. 		/// <summary>
  167. 		/// 返回指定索引的元素
  168. 		/// </summary>
  169. 		/// <param name="index"></param>
  170. 		/// <returns></returns>
  171. 		public T GetElem(int index)
  172. 		{
  173. 			int i = IsIndexVaild(index);
  174. 			if (i == -1) return default(T);
  176. 			return GetNode(index).Data;
  177. 		}
  179. 		/// <summary>
  180. 		/// 返回链表长度
  181. 		/// </summary>
  182. 		/// <returns></returns>
  183. 		public int GetLength()
  184. 		{
  185. 			return count;
  186. 		}
  188. 		/// <summary>
  189. 		/// 根据元素返回其索引值
  190. 		/// </summary>
  191. 		/// <param name="item"></param>
  192. 		/// <returns></returns>
  193. 		public int GetPos(T item)
  194. 		{
  195. 			int k = 0;
  196. 			Node<T> pstr = head.Next;
  197. 			while (pstr != null && item != null && !pstr.Data.Equals(item))
  198. 			{
  199. 				pstr = pstr.Next;
  200. 				k++;
  201. 			}
  203. 			if (pstr == null)
  204. 			{
  205. 				Console.WriteLine("所查找元素不存在");
  206. 				return -1;
  207. 			}
  209. 			return k ;
  210. 		}
  212. 		/// <summary>
  213. 		/// 判断链表是否为空
  214. 		/// </summary>
  215. 		/// <returns></returns>
  216. 		public bool IsEmpty()
  217. 		{
  218. 			if (head == null || head.Next == null) return true;
  219. 			return false;
  220. 		}
  222. 		/// <summary>
  223. 		/// 打印
  224. 		/// </summary>
  225. 		public void Print()
  226. 		{
  227. 			Node<T> pstr = head.Next;
  228. 			int i = 1;
  229. 			while(pstr != null)
  230. 			{
  231. 				Console.WriteLine("第 " + i++ + "个元素是： " + pstr.Data);
  232. 				pstr = pstr.Next;
  233. 			}
  234. 		}
  236. 		/// <summary>
  237. 		/// 判断索引是否错误
  238. 		/// </summary>
  239. 		/// <param name="index"></param>
  240. 		/// <returns></returns>
  241. 		public int IsIndexVaild(int index)
  242. 		{
  243. 			//判断索引是否越界
  244. 			if (index < 0 || index > count)
  245. 			{
  246. 				Console.WriteLine("索引越界，不存在该元素");
  247. 				return -1;
  248. 			}
  249. 			return 0;
  250. 		}
  252. 		/// <summary>
  253. 		/// 根据索引找到元素
  254. 		/// </summary>
  255. 		/// <param name="index"></param>
  256. 		/// <returns></returns>
  257. 		public Node<T> GetNode(int index)
  258. 		{
  259. 			int k = 0;
  260. 			Node<T> pstr = head;
  261. 			while (k++ < index)
  262. 			{
  263. 				pstr = pstr.Next;
  264. 			}
  265. 			return pstr;
  266. 		}
  267. 	}
  268. }

三. 双向链表

双向链表在思路上和单链表差不多，只是多了一个指向上一个节点的 Prev，所以代码上要更小心地处理。具体就不多赘述了，直接给出代码吧

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  7. namespace 线性表
  8. {
  9. 	class DBNode<T>
  10. 	{
  11. 		private T data;
  12. 		private DBNode<T> next;
  13. 		private DBNode<T> prev;
  15. 		public DBNode()
  16. 		{
  17. 			this.data = default(T);
  18. 			this.next = null;
  19. 			this.prev = null;
  20. 		}
  22. 		public DBNode(T value)
  23. 		{
  24. 			this.data = value;
  25. 			this.next = null;
  26. 			this.prev = null;
  27. 		}
  29. 		public DBNode(T value, DBNode<T> next)
  30. 		{
  31. 			this.data = value;
  32. 			this.next = next;
  33. 			this.prev = null;
  34. 		}
  36. 		public T Data
  37. 		{
  38. 			get { return data; }
  39. 			set { data = value; }
  40. 		}
  42. 		public DBNode<T> Next
  43. 		{
  44. 			get { return next; }
  45. 			set { next = value; }
  46. 		}
  48. 		public DBNode<T> Prev
  49. 		{
  50. 			get { return prev; }
  51. 			set { prev = value; }
  52. 		}
  53. 	}
  54. }

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  7. namespace 线性表
  8. {
  9. 	class DBLinkList<T> : MyList<T>
  10. 	{
  11. 		private DBNode<T> head;
  12. 		private DBNode<T> tail;
  13. 		private int count;
  15. 		/// <summary>
  16. 		/// 构造器
  17. 		/// </summary>
  18. 		public DBLinkList()
  19. 		{
  20. 			head = new DBNode<T>();
  21. 			tail = head;
  22. 			count = 0;
  23. 		}
  25. 		/// <summary>
  26. 		/// 实现下标访问法
  27. 		/// </summary>
  28. 		/// <param name="index"></param>
  29. 		/// <returns></returns>
  30. 		public T this[int index]
  31. 		{
  32. 			get
  33. 			{
  34. 				int i = IsIndexVaild(index);
  35. 				if (i == -1) return default(T);
  37. 				int k = 0;
  38. 				DBNode<T> pstr = head;
  39. 				while (k++ < index)
  40. 				{
  41. 					pstr = pstr.Next;
  42. 				}
  44. 				return pstr.Data;
  45. 			}
  46. 		}
  48. 		/// <summary>
  49. 		/// 在链表最末端添加新节点
  50. 		/// </summary>
  51. 		/// <param name="item"></param>
  52. 		public void Add(T item)
  53. 		{
  54. 			if (count == 0)
  55. 			{
  56. 				DBNode<T> DbNode = new DBNode<T>(item);
  57. 				DbNode.Prev = head;
  58. 				head.Next = DbNode;
  59. 				tail = DbNode;
  60. 				count++;
  61. 				return;
  62. 			}
  64. 			DBNode<T> tailDBNode = new DBNode<T>(item);
  65. 			tailDBNode.Prev = tail;
  66. 			tail.Next = tailDBNode;
  67. 			tail = tailDBNode;
  68. 			count++;
  69. 		}
  71. 		/// <summary>
  72. 		/// 在第 index 号元素后插入一个节点，index 为 1，2，3，4.....
  73. 		/// </summary>
  74. 		/// <param name="item"></param>
  75. 		/// <param name="index"></param>
  76. 		public void AddPost(T item, int index)
  77. 		{
  78. 			//判断索引是否越界
  79. 			int i = IsIndexVaild(index);
  80. 			if (i == -1) return;
  82. 			//找到索引元素
  83. 			DBNode<T> pstr = GetNode(index);
  85. 			//链接新节点
  86. 			DBNode<T> newNode = new DBNode<T>(item);
  87. 			newNode.Next = pstr.Next;
  88. 			newNode.Prev = pstr;
  89. 			if(pstr.Next != null) pstr.Next.Prev = newNode;
  90. 			pstr.Next = newNode;
  92. 			//如果是在最后节点添加
  93. 			if (index == count) tail = newNode;
  94. 			count++;
  95. 			pstr = null;
  96. 		}
  98. 		/// <summary>
  99. 		/// 在第 index 号元素前插入一个节点，index 为 1，2，3，4.....
  100. 		/// </summary>
  101. 		/// <param name="item"></param>
  102. 		/// <param name="index"></param>
  103. 		public void AddPre(T item, int index)
  104. 		{
  105. 			//判断索引是否越界
  106. 			int i = IsIndexVaild(index);
  107. 			if (i == -1) return;
  109. 			//找到索引的前一位元素
  110. 			DBNode<T> pstr = GetNode(index - 1);
  112. 			//链接新节点
  113. 			DBNode<T> newNode = new DBNode<T>(item);
  114. 			newNode.Next = pstr.Next;
  115. 			newNode.Prev = pstr;
  116. 			pstr.Next.Prev = newNode;
  117. 			pstr.Next = newNode;
  118. 			count++;
  119. 			pstr = null;
  121. 			//在 index 处AddPre相当于在 index - 1 处 AddPost，不过并不需要判断尾节点
  122. 		}
  124. 		/// <summary>
  125. 		/// 清空链表
  126. 		/// </summary>
  127. 		public void Clear()
  128. 		{
  129. 			head.Next = null;
  130. 			tail = head;
  131. 		}
  133. 		/// <summary>
  134. 		/// 删除指定位置的元素
  135. 		/// </summary>
  136. 		/// <param name="index"></param>
  137. 		/// <returns></returns>
  138. 		public T Delete(int index)
  139. 		{
  140. 			//判断索引是否越界
  141. 			int i = IsIndexVaild(index);
  142. 			if (i == -1) return default(T);
  144. 			//找到索引的前一位元素
  145. 			DBNode<T> pstr = head;
  146. 			int k = 0;
  147. 			while (k++ < index - 1 && pstr != null)
  148. 			{
  149. 				pstr = pstr.Next;
  150. 			}
  152. 			if (pstr.Next == null) return default(T);
  154. 			DBNode<T> qstr = pstr.Next;
  155. 			T t = qstr.Data;
  157. 			pstr.Next = qstr.Next;
  158. 			qstr.Next.Prev = pstr;		
  160. 			pstr = null;
  161. 			qstr.Next = null;
  162. 			qstr = null;
  163. 			count--;
  164. 			return t;
  165. 		}
  167. 		/// <summary>
  168. 		/// 按内容删除
  169. 		/// </summary>
  170. 		/// <param name="item"></param>
  171. 		/// <param name="isSecond"></param>
  172. 		/// <returns></returns>
  173. 		public T Delete(T item,bool isSecond = true)
  174. 		{
  176. 			int k = GetPos(item);
  177. 			if (k == -1) return default(T);
  178. 			int i = 0;
  180. 			DBNode<T> pstr = head;
  181. 			while (i++ < k - 1)
  182. 			{
  183. 				pstr = pstr.Next;
  184. 			}
  186. 			DBNode<T> qstr = pstr.Next;
  187. 			T t = qstr.Data;
  189. 			pstr.Next = qstr.Next;
  190. 			if(qstr.Next != null) qstr.Next.Prev = pstr;
  192. 			pstr = null;
  193. 			qstr.Next = null;
  194. 			qstr = null;
  195. 			count--;
  196. 			return t;
  197. 		}
  199. 		/// <summary>
  200. 		/// 返回指定索引的元素
  201. 		/// </summary>
  202. 		/// <param name="index"></param>
  203. 		/// <returns></returns>
  204. 		public T GetElem(int index)
  205. 		{
  206. 			int i = IsIndexVaild(index);
  207. 			if (i == -1) return default(T);
  209. 			int k = 0;
  210. 			DBNode<T> pstr = head;
  211. 			while (k++ < index)
  212. 			{
  213. 				pstr = pstr.Next;
  214. 			}
  216. 			return pstr.Data;
  217. 		}
  219. 		/// <summary>
  220. 		/// 返回链表长度
  221. 		/// </summary>
  222. 		/// <returns></returns>
  223. 		public int GetLength()
  224. 		{
  225. 			return count;
  226. 		}
  228. 		/// <summary>
  229. 		/// 根据元素返回其索引值
  230. 		/// </summary>
  231. 		/// <param name="item"></param>
  232. 		/// <returns></returns>
  233. 		public int GetPos(T item)
  234. 		{
  235. 			int k = 0;
  236. 			DBNode<T> pstr = head.Next;
  237. 			while (pstr != null && item != null && !pstr.Data.Equals(item))
  238. 			{
  239. 				pstr = pstr.Next;
  240. 				k++;
  241. 			}
  243. 			if (pstr == null)
  244. 			{
  245. 				Console.WriteLine("所查找元素不存在");
  246. 				return -1;
  247. 			}
  249. 			return k;
  250. 		}
  252. 		/// <summary>
  253. 		/// 判断链表是否为空
  254. 		/// </summary>
  255. 		/// <returns></returns>
  256. 		public bool IsEmpty()
  257. 		{
  258. 			if (head == null || head.Next == null) return true;
  259. 			return false;
  260. 		}
  262. 		/// <summary>
  263. 		/// 打印
  264. 		/// </summary>
  265. 		public void Print()
  266. 		{
  267. 			DBNode<T> pstr = head.Next;
  268. 			while (pstr != null)
  269. 			{
  270. 				Console.WriteLine(pstr.Data);
  271. 				pstr = pstr.Next;
  272. 			}
  273. 		}
  275. 		/// <summary>
  276. 		/// 判断索引是否错误
  277. 		/// </summary>
  278. 		/// <param name="index"></param>
  279. 		/// <returns></returns>
  280. 		public int IsIndexVaild(int index)
  281. 		{
  282. 			//判断索引是否越界
  283. 			if (index < 0 || index > count)
  284. 			{
  285. 				Console.WriteLine("索引越界，不存在该元素");
  286. 				return -1;
  287. 			}
  288. 			return 0;
  289. 		}
  291. 		/// <summary>
  292. 		/// 根据索引找到元素
  293. 		/// </summary>
  294. 		/// <param name="index"></param>
  295. 		/// <returns></returns>
  296. 		public DBNode<T> GetNode(int index)
  297. 		{
  298. 			int k = 0;
  299. 			DBNode<T> pstr = head;
  300. 			while (k++ < index)
  301. 			{
  302. 				pstr = pstr.Next;
  303. 			}
  304. 			return pstr;
  305. 		}
  306. 	}
  307. }

总结

事实上，链表是一种比较简单且常用的数据结构。实现起来并不困难，只是要小心谨慎。下一篇会说到跳跃链表，跳跃链表的效率更高。好了，希望本文能对大家有所帮助

​

【 C# 】（一） ------------- 泛型带头节点的单链表，双向链表实现的更多相关文章

  1. 带头节点的单链表-------C语言实现

    /***************************************************** Author:Simon_Kly Version:0.1 Date:20170520 De ...

  2. 不带头结点的单链表------C语言实现

    File name:no_head_link.c Author:SimonKly Version:0.1 Date: 2017.5.20 Description:不带头节点的单链表 Funcion L ...

  3. 有一个线性表，采用带头结点的单链表L来存储，设计一个算法将其逆置，且不能建立新节点，只能通过表中已有的节点的重新组合来完成。

    有一个线性表,采用带头结点的单链表L来存储,设计一个算法将其逆置,且不能建立新节点,只能通过表中已有的节点的重新组合来完成. 分析:线性表中关于逆序的问题,就是用建立链表的头插法.而本题要求不能建立新 ...

  4. java编写带头结点的单链表

    最近在牛客网上练习在线编程,希望自己坚持下去,每天都坚持下去练习,给自己一个沉淀,不多说了 我遇到了一个用java实现单链表的题目,就自己在做题中将单链表完善了一下,希望大家作为参考也熟悉一下,自己 ...

  5. C/C++中创建(带头结点、不带头结点的)单链表

    1.带头结点的单链表(推荐使用带头结点的单链表)(采用尾插法) 了解单链表中节点的构成 从上图可知,节点包含数据域和指针域,因此,在对节点进行定义时,我们可以如下简单形式地定义: /* 定义链表 */ ...

  6. c语言实现--不带头结点的单链表操作

    1,不带头结点的单链表操作中,除了InitList(),GetElem(),ListInsert(),ListDelete()操作与带头结点的单链表有差别外,其它的操作基本上一样. 2,不带头结点单链 ...

  7. 链表习题（2）-一个集合用带头结点的单链表L表示，编写算法删除其值最大的结点。

    /*一个集合用带头结点的单链表L表示,编写算法删除其值最大的结点.*/ /* 算法思想:使用pre,p,premax,max四个指针,pre和p进行比较,premax和max进行最后的删除操作 通过遍 ...

  8. 链表习题（1）-设计一个递归算法，删除不带头结点的单链表L中所有值为x的结点

    /*设计一个递归算法,删除不带头结点的单链表L中所有值为x的结点*/ /* 算法思想:设f(L,x)的功能是删除以L为首结点指针的单链表中所有值等于x的结点, 则显然有f(L->next,x)的 ...

  9. C语言：将带头节点的单向链表结点域中的数据从小到大排序。-求出单向链表结点（不包括头节点）数据域中的最大值。-将M*N的二维数组中的数据，按行依次放入一维数组，

    //函数fun功能是将带头节点的单向链表结点域中的数据从小到大排序. //相当于数组的冒泡排序. #include <stdio.h> #include <stdlib.h> ...

随机推荐

  1. 1070. [SCOI2007]修车【费用流】

    Description 同一时刻有N位车主带着他们的爱车来到了汽车维修中心.维修中心共有M位技术人员,不同的技术人员对不同 的车进行维修所用的时间是不同的.现在需要安排这M位技术人员所维修的车及顺序, ...

  2. P2110 欢总喊楼记

    题目描述 诗经有云: 关关雎鸠,在河之洲.窈窕淑女,君子好逑. 又是一个被风吹过的夏天--一日欢总在图书馆中自习,抬起头来,只见一翩跹女子从面前飘过,真是回眸一笑百媚生,六宫粉黛无颜色!一阵诗情涌上欢 ...

  3. [BJWC2008]雷涛的小猫

    嘟嘟嘟 dp. 刚开始我想的是dp[i][j]表示在第 i 棵树上,高度为h能吃到的最多的果子,如此能得到转移方程: dp[i][j] = max(dp[i][j + 1], dp[k][j + de ...

  4. Jsp实现在线作业提交系统

    Jsp实现在线作业提交系统 作为 Computer Science 的学生,凌晨四点之前睡都应该感到羞耻. 项目托管地址:https://github.com/four-in-the-morning/ ...

  5. C语言不使用加号实现加法运算的几种方法

    今天看到<编码:隐匿在计算机软硬件背后的语言>的第十二章:二进制加法器.讲述了全加器,半加器的原理以及如何实现加法.实现加法时所使用的全加器,半加器中包含的所有逻辑门在C语言中都有相应的运 ...

  6. 20155314 2016-2017-2 《Java程序设计》第2周学习总结

    20155314 2016-2017-2 <Java程序设计>第2周学习总结 教材学习内容总结 学习目标 了解Java编程风格 认识Java的类型与变量 掌握Java流程控制的方法(分支. ...

  7. pip问题解决方案

    错误信息:usr/bin/pip: No such file or directory 解决办法(一共四步,按照下面的步骤来从1到4,最后你会发现问题都解决了): 1.which pip /usr/l ...

  8. 初识Qt窗口界面

    1.新建一个新的Qt Gui应用,项目名称随意,例如MyMainWindow,基类选择QMainWindow,类名为MainWindow. 2.项目建立后,双击mainwindow.ui文件,在界面的 ...

  9. sql查询以及常见问题理解解析

    推荐w3挺好的基础网站:https://www.w3cschool.cn/t_sql/t_sql_date_functions.html =,<,>,> =,<=,IN,BET ...

  10. P1586 四方定理

    题目描述 四方定理是众所周知的:任意一个正整数nn ,可以分解为不超过四个整数的平方和.例如:25=1^{2}+2^{2}+2^{2}+4^{2}25=12+22+22+42 ,当然还有其他的分解方案 ...