- 为什么要使用单向链表?
首先,单向链表的删除非常方便,如果你的程序设计中,需要对数据删除操作频率高,那么,以单向链表作为数据结构是一个不错的选择。链表的删除操作只是需要删除的位置删除数据,不需要对该位置后面的元素一一移位,这样大大提高了删除操作的效率;插入操作同样的,由于是非顺序非连续的存储结构,链表在插入时的复杂度是O(1),仅需创建一个节点修改该位置处的指针关系,而数组结构的复杂度在O(n),同时,如果数组的容量达到一个限度的时候,会触发扩容操作。
然而,尽管链表的删除和插入操作比数字结构的效率高,但是索引一个链表上的数据的开销要比数组结构的要大,前者是O(logn)的复杂度,后者仅是O(1)。我们在程序设计的时候,需要按照我们自己的需求来创建,世上就没有十全十美的事物。
2.单向链表的代码实现(C#)
分析
链表的存储形式不像数组,需要连续的内存地址,链表中每个元素的内存地址可以是分散的。无序的,这就需要在每个data 中额外存储一个指向它的下一个data地址的变量:next,以获取链表中的每个元素。
我们称data和next组成的这个数据结构为一个“节点”,是这个节点有最基本的两个字段。
下面开始构造链表的属性和行为。
一个链表有头信息 Head,表示自己长度的信息 Length等属性;
链表的行为有索引元素、在尾部添加元素、任意位置插入元素、删除指定位置上的元素、获取某个位置的元素、计算元素在表的位置等。
// 这是链表中,单个数据节点的父类,T 是用来确定数据类型的参数,类的固定书写格式
public class LoopLinkNode<T> where T : object
{
private T data;// 节点的数据域,
private LoopLinkNode<T> next; // 该节点的下一个节点(指针域)
public T Data
{
set { data = value; }
get { return data; }
}
public LoopLinkNode<T> Next
{
set { next = value; }
get { return next; }
}
// 构造函数,节点的创建
public LoopLinkNode(T data)
{
this.data = data;
next = null;
}
}
// 这是链表的父类,链表的属性、字段、行为都在这里定义
public class LoopLink<T> where T : object
{
// 链表的构造函数,在 new 的时候调用,这里创建了一个空的链表,head 节点为空
public LoopLink()
{
this.head = null;
}
// 链表的头信息属性
private LoopLinkNode<T> head;
public LoopLinkNode<T> Head
{
set
{
head = value;
head.Next = head;
}
get { return head; }
}
// 链表的长度属性
public int Length { get { return GetLength(); } }
/// <summary>
/// 索引器
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public LoopLinkNode<T> this[int index]
{
set
{
if (IsEmpty())
throw new Exception("链表为空");
if (index < 0 || index > this.Length - 1)
throw new Exception("索引超出链表长度");
LoopLinkNode<T> node = head;
for (int i = 0; i < index; i++)
{
node = node.Next;
}
node.Data = value.Data;
node.Next = value.Next;
}
get
{
if (IsEmpty())
throw new Exception("链表为空");
if (index < 0 || index > this.Length - 1)
throw new Exception("索引超出链表长度");
LoopLinkNode<T> node = head;
for (int i = 0; i < index; i++)
{
node = node.Next;
}
return node;
}
}
/// <summary>
/// 获取链表长度
/// </summary>
/// <returns></returns>
public int GetLength()
{
if (IsEmpty())
return 0;
int length = 1;
LoopLinkNode<T> temp = head;
while (temp.Next != head)
{
temp = temp.Next;
length++;
}
return length;
}
/// <summary>
/// 清空链表所有元素,只需要将 头信息置空即可
/// </summary>
public void Clear()
{
this.head = null;
}
/// <summary>
/// 检查链表是否为空
/// </summary>
/// <returns></returns>
public bool IsEmpty()
{
if (head == null)
return true;
return false;
}
/// <summary>
/// 检查链表是否已满
/// </summary>
/// <returns></returns>
public bool IsFull()
{
return false;
}
/// <summary>
/// 在链表的最末端添加一个新项
/// </summary>
/// <param name="item"></param>
public void Append(T item)
{
if (IsEmpty())
{
this.Head = new LoopLinkNode<T>(item);
return;
}
LoopLinkNode<T> node = new LoopLinkNode<T>(item);
LoopLinkNode<T> temp = head;
while (temp.Next != head)
{
temp = temp.Next;
}
temp.Next = node;
node.Next = head;
}
/// <summary>
/// 在链表的指定位置添加一个新项
/// </summary>
/// <param name="item"></param>
/// <param name="index"></param>
public void Insert(T item, int index)
{
if (IsEmpty())
throw new Exception("数据链表为空");
if (index < 0 || index > this.Length)
throw new Exception("给定索引超出链表长度");
LoopLinkNode<T> temp = new LoopLinkNode<T>(item);
LoopLinkNode<T> node = head;
if (index == 0)
{
while (node.Next != head)
{
node = node.Next;
}
node.Next = temp;
temp.Next = this.head;
return;
}
for (int i = 0; i < index - 1; i++)
{
node = node.Next;
}
LoopLinkNode<T> temp2 = node.Next;
node.Next = temp;
temp.Next = temp2;
}
/// <summary>
/// 删除链表指定位置的项目
/// </summary>
/// <param name="index"></param>
public void Delete(int index)
{
if (IsEmpty())
throw new Exception("链表为空,没有可清除的项");
if (index < 0 || index > this.Length - 1)
throw new Exception("给定索引超出链表长度");
LoopLinkNode<T> node = head;
if (index == 0)
{
while (node.Next != head)
{
node = node.Next;
}
this.head = head.Next;
node.Next = this.head;
return;
}
for (int i = 0; i < index - 1; i++)
{
node = node.Next;
}
node.Next = node.Next.Next;
}
/// <summary>
/// 获取链表指定位置的元素的值
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
public T GetItem(int index)
{
if (index < 0 || index > this.Length - 1)
throw new Exception("索引超出链表长度");
LoopLinkNode<T> node = head;
for (int i = 0; i < index; i++)
{
node = node.Next;
}
return node.Data;
}
/// <summary>
/// 根据给定的值查找链表中哪个元素为这个值,如果链表中存在两个元素值相同,则取排在链表前面的元素
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public int Locate(T value)
{
if (IsEmpty())
throw new Exception("链表为空");
LoopLinkNode<T> node = head;
int index = 0;
while (node.Next != head)
{
if (node.Data.Equals(value))
return index;
else
index++;
node = node.Next;
}
if (node.Data.Equals(value))
return index;
else
return -1;
}
}
测试代码:
private void Start()
{
LoopLink<Vector2> linkList = new LoopLink<Vector2>();
for (int i = 0; i < 10; i++)
{
linkList.Append(new Vector2(i, i % 2));
}
Debug.Log("原始数据:");
for (int i = 0; i < linkList.Length; i++)
{
Debug.Log(linkList[i].Data);
}
Debug.Log("在倒数第二个的位置处插入元素 (999, 999) 后:");
linkList.Insert(new Vector2(999, 999), linkList.Length - 2);
for (int i = 0; i < linkList.Length; i++)
{
Debug.Log(linkList[i].Data);
}
linkList.Delete(linkList.Length - 1);
Debug.Log("删除最后一个元素:");
for (int i = 0; i < linkList.Length; i++)
{
Debug.Log(linkList[i].Data);
}
Debug.Log("取出第2个元素是: " + linkList.GetItem(1));
Debug.Log("(0,0)元素在链表中的索引是:" + linkList.Locate(Vector2.zero));
}
测试结果: