【 C# 】（一） ------------- 泛型带头节点的单链表，双向链表实现

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

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

一. 定义一个链表接口 MyList

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

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

二. 实现单链表

2.1 节点类

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

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

namespace 线性表
{
	/// <summary>
	/// 单向链表节点
	/// </summary>
	/// <typeparam name="T"></typeparam>
	class Node<T>
	{
		private T data;						//内容域
		private Node<T> next;				//下一节点

		public Node()
		{
			this.data = default(T);
			this.next = null;
		}

		public Node(T value)
		{
			this.data = value;
			this.next = null;
		}

		public Node(T value,Node<T> next)
		{
			this.data = value;
			this.next = next;
		}

		public T Data
		{
			get { return data; }
			set { data = value; }
		}

		public Node<T> Next
		{
			get { return next; }
			set { next = value; }
		}
	}
}
2.2 链表类

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

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

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

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

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

构造函数：
		/// <summary>
		/// 构造器
		/// </summary>
		public LinkList()
		{
			head = new Node<T>();
			tail = head;
			count = 0;
		}
在我们实现成员函数之前，先实现两个特别的方法，因为在许多的成员方法中都要做两个操作：

判断索引 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

.

其它功能读者可以自行测试，完整代码：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 线性表
{
	class LinkList<T> : MyList<T>
	{
		private Node<T> head;			//头结点
		private Node<T> tail;			//尾节点
		private int count;				//节点个数

		/// <summary>
		/// 构造器
		/// </summary>
		public LinkList()
		{
			head = new Node<T>();
			tail = head;
			count = 0;
		}

		/// <summary>
		/// 实现下标访问法
		/// </summary>
		/// <param name="index"></param>
		/// <returns></returns>
		public T this[int index]
		{
			get
			{
				int i = IsIndexVaild(index);
				if(i == -1) return default(T);

				int k = 0;
				Node<T> pstr = head;
				while (k++ < index )
				{
					pstr = pstr.Next;
				}

				return pstr.Data;

			}
		}

		/// <summary>
		/// 在链表最末端添加新节点
		/// </summary>
		/// <param name="item"></param>
		public void Add(T item)
		{
			Node<T> tailNode = new Node<T>(item);
			tail.Next = tailNode;
			tail = tailNode;
			if (count == 0) head.Next = tailNode;
			count++;
		}


		/// <summary>
		/// 在第 index 号元素后插入一个节点
		/// <param name="item"></param>
		/// <param name="index"></param>
		public void AddPost(T item, int index)
		{
			int i = IsIndexVaild(index);
			if (i == -1) return;

			//找到索引元素
			Node<T> pstr = GetNode(index);

			//链接新节点
			Node<T> node = new Node<T>(item);
			node.Next = pstr.Next;
			pstr.Next = node;
			if (index == count) tail = node;
			count++;
			pstr = null;
		}


		/// <summary>
		/// 在第 index 号元素前插入一个节点
		/// </summary>
		/// <param name="item"></param>
		/// <param name="index"></param>
		public void AddPre(T item, int index)
		{
			int i = IsIndexVaild(index);
			if (i == -1) return;

			//找到索引的前一位元素
			Node<T> pstr = GetNode(index - 1);

			//链接新节点
			Node<T> node = new Node<T>(item);
			node.Next = pstr.Next;
			pstr.Next = node;
			count++;
			pstr = null;
		}


		/// <summary>
		/// 清空链表
		/// </summary>
		public void Clear()
		{
			head.Next = null;
			tail = head;
		}


		/// <summary>
		/// 删除指定位置的元素
		/// </summary>
		/// <param name="index"></param>
		/// <returns></returns>
		public T Delete(int index)
		{
			int i = IsIndexVaild(index);
			if (i == -1) return default(T);

			//找到索引的前一位元素
			Node<T> pstr = GetNode(index - 1);

			if (pstr.Next == null) return default(T);

			Node<T> qstr = pstr.Next;
			pstr.Next = qstr.Next;
			T t = qstr.Data;
			pstr = null;
			qstr.Next = null;
			qstr = null;
			count--;
			return t;
		}

		/// <summary>
		/// 按内容删除
		/// </summary>
		/// <param name="item"></param>
		/// <param name="isSecond"></param>
		/// <returns></returns>
		public T Delete(T item,bool isSecond = true)
		{

			int k = GetPos(item);
			if (k == -1) return default(T);
			int i = 0;

			Node<T> pstr = head;
			while (i++ < k -1)
			{
				pstr = pstr.Next;
			}
			Node<T> qstr = pstr.Next;
			pstr.Next = qstr.Next;
			T t = qstr.Data;
			pstr = null;
			qstr.Next = null;
			qstr = null;
			count--;
			return t;
		}

		/// <summary>
		/// 返回指定索引的元素
		/// </summary>
		/// <param name="index"></param>
		/// <returns></returns>
		public T GetElem(int index)
		{
			int i = IsIndexVaild(index);
			if (i == -1) return default(T);

			return GetNode(index).Data;
		}

		/// <summary>
		/// 返回链表长度
		/// </summary>
		/// <returns></returns>
		public int GetLength()
		{
			return count;
		}

		/// <summary>
		/// 根据元素返回其索引值
		/// </summary>
		/// <param name="item"></param>
		/// <returns></returns>
		public int GetPos(T item)
		{
			int k = 0;
			Node<T> pstr = head.Next;
			while (pstr != null && item != null && !pstr.Data.Equals(item))
			{
				pstr = pstr.Next;
				k++;
			}

			if (pstr == null)
			{
				Console.WriteLine("所查找元素不存在");
				return -1;
			}

			return k ;
		}

		/// <summary>
		/// 判断链表是否为空
		/// </summary>
		/// <returns></returns>
		public bool IsEmpty()
		{
			if (head == null || head.Next == null) return true;
			return false;
		}

		/// <summary>
		/// 打印
		/// </summary>
		public void Print()
		{
			Node<T> pstr = head.Next;
			int i = 1;
			while(pstr != null)
			{
				Console.WriteLine("第 " + i++ + "个元素是： " + pstr.Data);
				pstr = pstr.Next;
			}
		}

		/// <summary>
		/// 判断索引是否错误
		/// </summary>
		/// <param name="index"></param>
		/// <returns></returns>
		public int IsIndexVaild(int index)
		{
			//判断索引是否越界
			if (index < 0 || index > count)
			{
				Console.WriteLine("索引越界，不存在该元素");
				return -1;
			}
			return 0;
		}

		/// <summary>
		/// 根据索引找到元素
		/// </summary>
		/// <param name="index"></param>
		/// <returns></returns>
		public Node<T> GetNode(int index)
		{
			int k = 0;
			Node<T> pstr = head;
			while (k++ < index)
			{
				pstr = pstr.Next;
			}
			return pstr;
		}
	}
}

三. 双向链表

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

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 线性表
{
	class DBNode<T>
	{
		private T data;
		private DBNode<T> next;
		private DBNode<T> prev;

		public DBNode()
		{
			this.data = default(T);
			this.next = null;
			this.prev = null;
		}

		public DBNode(T value)
		{
			this.data = value;
			this.next = null;
			this.prev = null;
		}

		public DBNode(T value, DBNode<T> next)
		{
			this.data = value;
			this.next = next;
			this.prev = null;
		}

		public T Data
		{
			get { return data; }
			set { data = value; }
		}

		public DBNode<T> Next
		{
			get { return next; }
			set { next = value; }
		}

		public DBNode<T> Prev
		{
			get { return prev; }
			set { prev = value; }
		}
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 线性表
{
	class DBLinkList<T> : MyList<T>
	{
		private DBNode<T> head;
		private DBNode<T> tail;
		private int count;

		/// <summary>
		/// 构造器
		/// </summary>
		public DBLinkList()
		{
			head = new DBNode<T>();
			tail = head;
			count = 0;
		}

		/// <summary>
		/// 实现下标访问法
		/// </summary>
		/// <param name="index"></param>
		/// <returns></returns>
		public T this[int index]
		{
			get
			{
				int i = IsIndexVaild(index);
				if (i == -1) return default(T);

				int k = 0;
				DBNode<T> pstr = head;
				while (k++ < index)
				{
					pstr = pstr.Next;
				}

				return pstr.Data;
			}
		}

		/// <summary>
		/// 在链表最末端添加新节点
		/// </summary>
		/// <param name="item"></param>
		public void Add(T item)
		{
			if (count == 0)
			{
				DBNode<T> DbNode = new DBNode<T>(item);
				DbNode.Prev = head;
				head.Next = DbNode;
				tail = DbNode;
				count++;
				return;
			}

			DBNode<T> tailDBNode = new DBNode<T>(item);
			tailDBNode.Prev = tail;
			tail.Next = tailDBNode;
			tail = tailDBNode;
			count++;
		}


		/// <summary>
		/// 在第 index 号元素后插入一个节点，index 为 1，2，3，4.....
		/// </summary>
		/// <param name="item"></param>
		/// <param name="index"></param>
		public void AddPost(T item, int index)
		{
			//判断索引是否越界
			int i = IsIndexVaild(index);
			if (i == -1) return;

			//找到索引元素
			DBNode<T> pstr = GetNode(index);

			//链接新节点
			DBNode<T> newNode = new DBNode<T>(item);
			newNode.Next = pstr.Next;
			newNode.Prev = pstr;
			if(pstr.Next != null) pstr.Next.Prev = newNode;
			pstr.Next = newNode;

			//如果是在最后节点添加
			if (index == count) tail = newNode;
			count++;
			pstr = null;
		}


		/// <summary>
		/// 在第 index 号元素前插入一个节点，index 为 1，2，3，4.....
		/// </summary>
		/// <param name="item"></param>
		/// <param name="index"></param>
		public void AddPre(T item, int index)
		{
			//判断索引是否越界
			int i = IsIndexVaild(index);
			if (i == -1) return;


			//找到索引的前一位元素
			DBNode<T> pstr = GetNode(index - 1);

			//链接新节点
			DBNode<T> newNode = new DBNode<T>(item);
			newNode.Next = pstr.Next;
			newNode.Prev = pstr;
			pstr.Next.Prev = newNode;
			pstr.Next = newNode;
			count++;
			pstr = null;

			//在 index 处AddPre相当于在 index - 1 处 AddPost，不过并不需要判断尾节点
		}


		/// <summary>
		/// 清空链表
		/// </summary>
		public void Clear()
		{
			head.Next = null;
			tail = head;
		}


		/// <summary>
		/// 删除指定位置的元素
		/// </summary>
		/// <param name="index"></param>
		/// <returns></returns>
		public T Delete(int index)
		{
			//判断索引是否越界
			int i = IsIndexVaild(index);
			if (i == -1) return default(T);

			//找到索引的前一位元素
			DBNode<T> pstr = head;
			int k = 0;
			while (k++ < index - 1 && pstr != null)
			{
				pstr = pstr.Next;
			}

			if (pstr.Next == null) return default(T);

			DBNode<T> qstr = pstr.Next;
			T t = qstr.Data;

			pstr.Next = qstr.Next;
			qstr.Next.Prev = pstr;		

			pstr = null;
			qstr.Next = null;
			qstr = null;
			count--;
			return t;
		}

		/// <summary>
		/// 按内容删除
		/// </summary>
		/// <param name="item"></param>
		/// <param name="isSecond"></param>
		/// <returns></returns>
		public T Delete(T item,bool isSecond = true)
		{

			int k = GetPos(item);
			if (k == -1) return default(T);
			int i = 0;

			DBNode<T> pstr = head;
			while (i++ < k - 1)
			{
				pstr = pstr.Next;
			}

			DBNode<T> qstr = pstr.Next;
			T t = qstr.Data;

			pstr.Next = qstr.Next;
			if(qstr.Next != null) qstr.Next.Prev = pstr;

			pstr = null;
			qstr.Next = null;
			qstr = null;
			count--;
			return t;
		}

		/// <summary>
		/// 返回指定索引的元素
		/// </summary>
		/// <param name="index"></param>
		/// <returns></returns>
		public T GetElem(int index)
		{
			int i = IsIndexVaild(index);
			if (i == -1) return default(T);

			int k = 0;
			DBNode<T> pstr = head;
			while (k++ < index)
			{
				pstr = pstr.Next;
			}

			return pstr.Data;
		}

		/// <summary>
		/// 返回链表长度
		/// </summary>
		/// <returns></returns>
		public int GetLength()
		{
			return count;
		}

		/// <summary>
		/// 根据元素返回其索引值
		/// </summary>
		/// <param name="item"></param>
		/// <returns></returns>
		public int GetPos(T item)
		{
			int k = 0;
			DBNode<T> pstr = head.Next;
			while (pstr != null && item != null && !pstr.Data.Equals(item))
			{
				pstr = pstr.Next;
				k++;
			}

			if (pstr == null)
			{
				Console.WriteLine("所查找元素不存在");
				return -1;
			}

			return k;
		}

		/// <summary>
		/// 判断链表是否为空
		/// </summary>
		/// <returns></returns>
		public bool IsEmpty()
		{
			if (head == null || head.Next == null) return true;
			return false;
		}

		/// <summary>
		/// 打印
		/// </summary>
		public void Print()
		{
			DBNode<T> pstr = head.Next;
			while (pstr != null)
			{
				Console.WriteLine(pstr.Data);
				pstr = pstr.Next;
			}
		}

		/// <summary>
		/// 判断索引是否错误
		/// </summary>
		/// <param name="index"></param>
		/// <returns></returns>
		public int IsIndexVaild(int index)
		{
			//判断索引是否越界
			if (index < 0 || index > count)
			{
				Console.WriteLine("索引越界，不存在该元素");
				return -1;
			}
			return 0;
		}

		/// <summary>
		/// 根据索引找到元素
		/// </summary>
		/// <param name="index"></param>
		/// <returns></returns>
		public DBNode<T> GetNode(int index)
		{
			int k = 0;
			DBNode<T> pstr = head;
			while (k++ < index)
			{
				pstr = pstr.Next;
			}
			return pstr;
		}
	}
}

总结

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

posted @ 2018-09-24 22:10 爱喝柠檬的二哈阅读(1102) 评论(0) 编辑收藏举报

刷新页面返回顶部

爱喝柠檬的二哈

【 C# 】（一） ------------- 泛型带头节点的单链表，双向链表实现

一. 定义一个链表接口 MyList

二. 实现单链表

2.1 节点类

2.2 链表类

三. 双向链表

总结

公告