重溫數據結構系列隨筆：單鏈表（c#模擬實現）
上一節我們講述了數據結構的基本概念，這一節讓我們來討論下單鏈表的概念和實現
我從書中簡單摘錄下單鏈表概念
簡單而言單鏈表的是通過許多節點構成，每個節點包含2個重要元素：該節點數據（數據域）和指向下個節點的地址（指針域）
這樣說太枯燥了，讓我們直接用c# 來一步步實現
既然一個節點是由（數據域）和（指針域）構成，那我們簡單DIY一個LinkNode類
/// <summary>
/// 單鏈表的節點
/// </summary>
public class LinkNode
{
//節點數據域
public object LinkNodeData { get; set; }
//自己節點的地址
public Guid SelfAddress { get; set; }
//下個節點的地址指針（存儲位置）
public Guid NextAddress { get; set; }
}
繼續來了解概念了，既然節點准備好了，那我們要了解節點是怎么通過指針域連接在一起的，看圖
圖中節點就是一個小矩形，數據域是姓名，指針域就是那個箭頭所表示的指向它的后繼，頭節點h->zhao->Qian->....Wang
這樣連接起來就是一個完整的單鏈表，頭結點的數據域可以是任何信息，尾節點的地址域是空（他沒有后繼節點了）
好，代碼中我們只有node 沒有LinkTable,那我們就按照上圖來建立一個LinkTable類
public class LinkTable
{
//定義一個LinkNode集合
List<LinkNode> list = new List<LinkNode>();
public LinkTable()
{
}
/// <summary>
/// 進行單向鏈表初始化
/// </summary>
public void InitialList()
{
//添加5個節點擁有唯一的guid作為自身地址，后繼節點地址為guid.empty
for (int i = 0; i < 5; i++)
{
list.Add
(
new LinkNode { LinkNodeData = string.Format("第{0}個節點", i + 1), SelfAddress = Guid.NewGuid(), NextAddress = Guid.Empty }
);
}
s
var j = 0;
//將節點的 指針域指向下一個節點的地址
list.ForEach
(
(linkNode) =>
{
if (j < list.Count - 1)
{
linkNode.NextAddress = list.Skip(++j).FirstOrDefault().SelfAddress;
}
}
);
}
}
LinkTable類包含一個LinkNode集合 和一個初始方法，這個方法是先添加節點數據到集合中，然后將節點的地址域一一連接起來
肯定會有朋友問我，那么你怎么在單鏈表中插入數據或刪除數據呢？
非常棒的問題，看圖：
圖中可以看出a節點的后繼是b節點，a節點的指針域指向b節點，那如果在a節點和b節點中添加一個新的節點那情況又如何？
其實圖中已經表達出來了，將a的指針域指向新節點，然后將新節點的指針域指向b節點
馬上看代碼理解
既然是添加節點那我們在LinkTable類中添加方法就行
/// <summary>
/// 添加一個新節點
/// </summary>
/// <param name="node">節點</param>
/// <param name="addIndex">在index處添加節點</param>
public void AddNode(LinkNode node, int addIndex)
{
if (this.list == null || node == null)
{
// 如果鏈表為空則初始鏈表並且添加節點
this.InitialList();
}
if (addIndex < 0 || addIndex > list.Count)
{
throw new IndexOutOfRangeException("removeIndex超出范圍");
}
var listCount = list.Count;
//注意，得到新插入節點的前一個索引位置
var prev = addIndex - 1 <= 0 || listCount <= 0 ? 0 : addIndex - 1;
//注意，得到新插入節點的后一個索引位置
var after = listCount <= 0 ? 0 :
addIndex > listCount - 1 ? listCount - 1 : addIndex;
//插入后前一個節點
var prevNode = list[prev];
//插入后后一個節點
var afterNode = list[after];
//將前一個節點的指針域指向新節點
node.NextAddress = afterNode.SelfAddress;
//將新節點的指針域指向后一個節點
prevNode.NextAddress = node.SelfAddress;
//判斷是否插入到最后一個位置
if (addIndex == list.Count)
{
node.NextAddress = Guid.Empty;
list.Add(node);
}
else
{
// 插入新節點
list.Insert(addIndex, node);
}
}
代碼注釋能夠幫助你了解下添加節點的具體過程，請大家仔細消化下
最后是刪除一個節點的情況：
和添加節點正好逆向思維，當我們刪除b節點時,我們要將a節點的指針域指向c節點保證我們的單鏈表不被破壞
刪除方法同樣寫在LinkTable類中
/// <summary>
/// 通過索引刪除
/// </summary>
/// <param name="removeIndex"></param>
/// <returns></returns>
public void Remove(int removeIndex)
{
if (this.list == null)
{
// 如果鏈表為空則初始鏈表並且添加節點
this.InitialList();
}
if (removeIndex > this.list.Count - 1 || removeIndex < 0)
{
throw new IndexOutOfRangeException("removeIndex超出范圍");
}
var preIndex = removeIndex - 1;
var afterIndex = removeIndex + 1;
var preNode = list[preIndex];
var afterNode = list[afterIndex];
//將被刪除節點前后的指針域進行整理
preNode.NextAddress = afterNode.SelfAddress;
//刪除該節點
list.Remove(list[removeIndex]);
}
ok,這就是單鏈表的一個簡單理解，請大家務必牢記，因為后章的循環列表將更復雜，單鏈表只是一個鏈表的基礎（一以下是完整代碼及輸出情況）
View Code
class Program
{
static void Main(string[] args)
{
LinkTable table = new LinkTable();
//初始化
table.InitialList();
//嘗試添加一個新節點
table.AddNode
(
new LinkNode { LinkNodeData="新節點",NextAddress=Guid.Empty, SelfAddress=Guid.NewGuid()},
4
);
//刪除一個節點
table.Remove(1);
var i = 0;
//循環顯示
table.list.ForEach
(
(linkNode) =>
{
if (i ==table.list.Count - 1)
{
Console.Write("{0} ->{1}", linkNode.LinkNodeData, "Null");
}
else
{
Console.Write("{0} ->", linkNode.LinkNodeData);
}
i++;
}
);
Console.ReadLine();
}
}
/// <summary>
/// 單鏈表的節點
/// </summary>
public class LinkNode
{
//節點數據域
public object LinkNodeData { get; set; }
//自己節點的地址
public Guid SelfAddress { get; set; }
//下個節點的地址指針（存儲位置）
public Guid NextAddress { get; set; }
}
/// <summary>
/// 單鏈表
/// </summary>
public class LinkTable
{
//定義一個LinkNode集合
public List<LinkNode> list = new List<LinkNode>();
public LinkTable()
{
}
/// <summary>
/// 進行單向鏈表初始化
/// </summary>
public void InitialList()
{
//添加10個節點擁有唯一的guid作為自身地址，后繼節點地址為guid.empty
for (int i = 0; i < 5; i++)
{
list.Add
(
new LinkNode { LinkNodeData = string.Format("第{0}個節點", i + 1), SelfAddress = Guid.NewGuid(), NextAddress = Guid.Empty }
);
}
var j = 0;
//將節點的 指針域指向下一個節點的地址
list.ForEach
(
(linkNode) =>
{
if (j < list.Count - 1)
{
linkNode.NextAddress = list.Skip(++j).FirstOrDefault().SelfAddress;
}
}
);
}
/// <summary>
/// 添加一個新節點
/// </summary>
/// <param name="node">節點</param>
/// <param name="addIndex">在index處添加節點</param>
public void AddNode(LinkNode node, int addIndex)
{
if (this.list == null || node == null)
{
// 如果鏈表為空則初始鏈表並且添加節點
this.InitialList();
}
if (addIndex < 0 || addIndex > list.Count)
{
throw new IndexOutOfRangeException("removeIndex超出范圍");
}
var listCount = list.Count;
//注意，得到新插入節點的前一個索引位置
var prev = addIndex - 1 <= 0 || listCount <= 0 ? 0 : addIndex - 1;
//注意，得到新插入節點的后一個索引位置
var after = listCount <= 0 ? 0 :
addIndex > listCount - 1 ? listCount - 1 : addIndex;
//插入后前一個節點
var prevNode = list[prev];
//插入后后一個節點
var afterNode = list[after];
//將前一個節點的指針域指向新節點
node.NextAddress = afterNode.SelfAddress;
//將新節點的指針域指向后一個節點
prevNode.NextAddress = node.SelfAddress;
//判斷是否插入到最后一個位置
if (addIndex == list.Count)
{
node.NextAddress = Guid.Empty;
list.Add(node);
}
else
{
// 插入新節點
list.Insert(addIndex, node);
}
}
/// <summary>
/// 通過索引刪除
/// </summary>
/// <param name="removeIndex"></param>
/// <returns></returns>
public void Remove(int removeIndex)
{
if (this.list == null)
{
// 如果鏈表為空則初始鏈表並且添加節點
this.InitialList();
}
if (removeIndex > this.list.Count - 1 || removeIndex < 0)
{
throw new IndexOutOfRangeException("removeIndex超出范圍");
}
var preIndex = removeIndex - 1;
var afterIndex = removeIndex + 1;
var preNode = list[preIndex];
var afterNode = list[afterIndex];
//將被刪除節點前后的指針域進行整理
preNode.NextAddress = afterNode.SelfAddress;
//刪除該節點
list.Remove(list[removeIndex]);
}
}
輸出：
希望大家對單鏈表有比較深的理解，其實在效率性能上這樣的單鏈表不及數組，因為數組更本沒有那么繁瑣，
大家在實際項目還是用數組比較好，下章會和大家先補充下c#中的LinkList類和Array類的區別（*數組和鏈表的區別(很重要)），
然后簡單說下循環鏈表。
敬請期待 ！