C#实现数据结构——线性表（下）
线性表链式存储结构
看了线性表的顺序存储，你肯定想线性表简是挺简单，但是我一开始怎么会知道有多少人排队？要分配多大的数组？而且插入和删除一个元素也太麻烦了，所有元素都要前移/后移，效率又低。
那怎么办呢？
这里就要用到我们的链式存储结构。
这就和我们的链条一样，一环接着一环，只要上一环知道下一环就行了。
你肯定觉得像食堂打饭那样太麻烦了，每个人都要傻傻地站在那里等，排队的位置又不够，人多了排队的地方都没有。那有没有别的方式？
也许我们可以换种方式。每个人都不需要站在那里等，也不需要知道队伍有多长前面有多少人，只需要知道你的下一个人（也就是后继）是谁就行了。比如第一个人去了打饭窗口，食堂大妈要他留下电话号码，随便去哪都行，到了打饭的时间点就电话通知他。第二个人也过来打饭，食堂大妈也让第二个人留下手机号，并且将他的手机号告诉第一个人：如果第一个人饭打完了就打电话叫第二个人来打饭。然后再将第三个人的号码告诉第二个人，由第二个人去通知第三个人，以此类推。这样每个人都不用排队了。
第一个人也就是头节点（头指针）。
当然，这在现实生活中是不可能的，那样子大妈会累死，再要碰到谁忘记通知下一个人，整个链表就断了。
初始化
每个人都不用呆在固定的地点排队，排队窗口的大小自然也就无所谓了，初始化时只需要知道第一个人的号码就可以了。当然链式结构存储的方式也和顺序不一样，不需要定义一个数组（因为没人排队了），但是需要保存一组数据及它的后继引用（指针）：
public class LinkNode<T>
{
public T Node
{
get; set;
}
public LinkNode<T> NextNode
{
get; set;
}
}
然后定义头节点：
private LinkNode<T> firstNode;
获取线性表的长度
想知道有多少人排队数一下就可以了，但是现在大家都没排队，怎么知道总共有多少人在等呢？那只有找到第一个人，再通过第一个人找到第二个，以此类推，直到找到没有后继的最后一个为止：
public int Length
{
get
{
var node = firstNode;
int length = 0;
while(node != null)
{
length++;
node = node.NextNode;
}
return length;
}
}
添加元素
每来一个人打饭，就需要将新来那个人的号码告诉之前的最后一个人：
public void Add(T item)
{
if(firstNode == null)
{
firstNode = new LinkNode<T> { Node = item };
}
else
{
LinkNode<T> node = firstNode;
while(node.NextNode != null)
{
node = node.NextNode;
}
node.NextNode = new LinkNode<T> { Node = item };
}
}
删除元素
如果你女朋友（程序员竟然也能找到女朋友！）突然临时约你出去吃饭，你当然觉得食堂这么难吃的饭给程序员吃就可以了，怎么可以给女朋友吃呢？但是作为一名有素质的程序员，你自然会想办法通知前一个人你不在食堂吃饭了，然后把你下一位的号码告诉你前一个人。但是你也不知道你前一个人是谁，于是找到食堂大妈，大妈找到第一个人，然后一层层找下去，终于找到你前一个人是谁（想一想这里可以怎样优化，让你直接找到前一个人）：
public void Delete(int index)
{
if(firstNode == null)
{
throw new Exception("List is empty");
}
if(index < 0)
{
throw new Exception("Location exception");
}
var node = firstNode.NextNode;
var prevNode = firstNode;
int i;
for(i = 1; i < index && node != null; i++)
{
prevNode = node;
node = node.NextNode;
}
if(i == index)
{
if(node.NextNode != null)
{
prevNode.NextNode = node.NextNode;
}
else
{
prevNode.NextNode = null;
}
}
else
{
throw new Exception("Locaion exception");
}
}
在指定位置插入元素
你女朋友约你去吃饭，于是你正打算放弃排队带她到外面吃，但是她是个勤俭持家的好女孩，认为外面吃饭太贵，还不如一起在食堂吃，省下来的钱给她买个包。正有此意又不好意思说的你一听赶紧把女朋友插在你后面。也就是你打完饭不再去通知你的下一位而是通知你女朋友，然后你女朋友再去通知他。是不是觉得链表的方式插队太方便了？神不知鬼不觉就能无痛插队，而且你女朋友通知他时，他还得说谢谢，这就是链式存储的优势：
public void Insert(T item, int index)
{
if (firstNode == null)
{
throw new Exception("List is empty");
}
if (index < 0)
{
throw new Exception("Location exception");
}
var node = firstNode.NextNode;
int i;
for (i = 1; i < index && node != null; i++)
{
node = node.NextNode;
}
if (i == index)
{
var nextNode = node.NextNode == null ? null : node.NextNode;
node.NextNode = new LinkNode<T> { Node = item, NextNode = nextNode };
}
else
{
throw new Exception("Locaion exception");
}
}
链式存储完整代码
/// <summary>
/// 线性表链式结构
/// </summary>
public class LinkList<T> : ILinearList<T>
{
private LinkNode<T> firstNode;
public int Length
{
get
{
var node = firstNode;
int length = 0;
while(node != null)
{
length++;
node = node.NextNode;
}
return length;
}
}
public void Add(T item)
{
if(firstNode == null)
{
firstNode = new LinkNode<T> { Node = item };
}
else
{
LinkNode<T> node = firstNode;
while(node.NextNode != null)
{
node = node.NextNode;
}
node.NextNode = new LinkNode<T> { Node = item };
}
}
public void Clear()
{
firstNode = null;
}
public void Delete(int index)
{
if(firstNode == null)
{
throw new Exception("List is empty");
}
if(index < 0)
{
throw new Exception("Location exception");
}
var node = firstNode.NextNode;
var prevNode = firstNode;
int i;
for(i = 1; i < index && node != null; i++)
{
prevNode = node;
node = node.NextNode;
}
if(i == index)
{
if(node.NextNode != null)
{
prevNode.NextNode = node.NextNode;
}
else
{
prevNode.NextNode = null;
}
}
else
{
throw new Exception("Locaion exception");
}
}
public T GetItem(int index)
{
if (firstNode == null)
{
throw new Exception("List is empty");
}
if (index < 0)
{
throw new Exception("Location exception");
}
var node = firstNode.NextNode;
int i;
for (i = 1; i < index && node != null; i++)
{
node = node.NextNode;
}
if (i == index)
{
return node.Node;
}
else
{
throw new Exception("Locaion exception");
}
}
public void Insert(T item, int index)
{
if (firstNode == null)
{
throw new Exception("List is empty");
}
if (index < 0)
{
throw new Exception("Location exception");
}
var node = firstNode.NextNode;
int i;
for (i = 1; i < index && node != null; i++)
{
node = node.NextNode;
}
if (i == index)
{
var nextNode = node.NextNode == null ? null : node.NextNode;
node.NextNode = new LinkNode<T> { Node = item, NextNode = nextNode };
}
else
{
throw new Exception("Locaion exception");
}
}
public bool IsEmpty()
{
return firstNode == null;
}
public int LocateItem(T t)
{
var index = 0;
var node = firstNode;
while(!node.Node.Equals(t))
{
index++;
if(node.NextNode == null)
{
return -1;
}
node = node.NextNode;
}
return index;
}
}
public class LinkNode<T>
{
public T Node
{
get; set;
}
public LinkNode<T> NextNode
{
get; set;
}
}
其它链表
之前说了，如果你想放弃排队，就要将排在你后面的人的手机号码告诉前一个人。但是由于不知道排在你前一个人是谁，所以只能去找食堂大妈，食堂大妈去找排在第一个的人，然后通过一层层找下去，才知道你前一个人是谁，这样就很麻烦，能不能让你不但知道后一个人的号码，也知道前一个人的呢？
当然可以，那就是双向链表。
双向链表就是在单链表的每个节点中，再设置一个指向其前驱节点的指针域。
用C#代码表示就是：
public class LinkNode<T>
{
public T Node
{
get; set;
}
public LinkNode<T> NextNode
{
get; set;
}
public LinkNode<T> PrevNode
{
get; set;
}
}
除了双向链表，还有循环链表、静态链表等，大家都可以自己实现。
单链表结构与顺序存储结构的优缺点
每种数据结构都不是万能的（不然还要这么多数据结构干嘛），单链表和顺序存储结构都有各自的优缺点和适用场景。
顺序存储结构的优缺点
优点：
- 无须为表示表中元素之间的逻辑关系而增加额外的存储空间（链表就需要额外存储一个指向后继的指针域）
- 可以快速地存取表中任意位置的元素（直接通过下标返回即可，链表需要循环去取）
缺点：
- 插入和删除操作需要移动大量元素
- 当线性表长度变化较大时，难以确定存储空间的容量（也可以通过达到一定长度时进行扩容的方式来改善）
- 造成存储空间的碎片（可以通过少于一定长度时进行压缩的方式来改善）
单链表的优缺点
对于插入或删除越是频繁的操作，单链表的效率优势就越是明显，但是获取元素的效率非常低。
适用场景
- 若线性表需要频繁查找，很少进行插入和删除操作，使用顺序存储结构。若需要频繁插入和删除，使用单链表结构。
- 若线性表中的元素个数变化较大或者根本不知道有多大时，最好使用单链表结构，这样可以不考虑存储空间的大小问题。而如果事先知道线性表的长度，使用顺序存储结构效率会高很多。
