.net集合类的研究--链表—ListDictionary,LinkedList<T>

链表是数据结构中存储数据的一种形式，我们经常使用的List,ArrayList,Hashtable等容器类，存取操作时是用数组Array来保存，ListDictionary和LinkedList不用Array，而是用链表的形式来保存。
  链表的优点和缺点

  以ListDictionary为例，在源码中，看不到Array类型的的变量，取而代之的是一个DictionaryNode类型的变量，查看该类的源码会发现，只包含一个key，一个value，和一个DictionaryNode类型的next变量，DictionaryNode的代码如下：
  

1. private class DictionaryNode
2. {
3.     public object key;
4.     public ListDictionary.DictionaryNode next;
5.     public object value;
6. }

复制代码

添加数据的时候，直接把当前节点的next变量赋值为新的节点，这样一个节点扣一个节点，就有了链的形式。
在链表中查找数据时，如调用Contains(object key) ：bool 方法，需要从链表的头节点依次遍历，逐个匹配，所以时间复杂度为O(n)，和List，ArrayList相比，在查询效率上并没有太大的区别。
那么链表的优势在哪里呢？答案是，节省内存空间。
在之前的文章有提到过，线性表和哈希表初始化时会将内部Array数组默认一个大小，List的初始值为4，Hashtable的为11，当添加数据碰到容量不足时，会将当前数组扩充2倍，这种做法不可避免要造成浪费。而链表不用数组保存，用节点相连，实实在在，添加几个节点，就占用几个节点的内存，相对于线性表和哈希表，链表没有浪费，因而占用内存空间较少。
除了节省空间以外，链表还有一个优点，那就是插入数据的灵活性。
可惜这一点在ListDictionary中并没有体现，每次添加数据，ListDictionary都要遍历整个链表，来确保没有重复节点，导致每次添加都要循环一次，添加数据的时间复杂度和查询数据的时间复杂度都为O（n），比线性表和哈希表要慢的多。
HybridDictionary-结合链表和哈希表的特点扬长避短

在.net的集合容器中，有一个名为HybridDictionary的类，充分利用了Hashtable查询效率高和ListDictionary占用内存空间少的优点，内置了Hashtable和ListDictionary两个容器，添加数据时内部逻辑如下：
当数据量小于8时，Hashtable为null，用ListDictionary保存数据。
当数据量大于8时，实例化Hashtable，数据转移到Hashtable中，然后将ListDictionary置为null。
HybridDictionary的Add方法的代码如下：

1. public void Add(object key, object value)
2. {
3.     if (this.hashtable != null)
4.     {
5.         this.hashtable.Add(key, value);
6.     }
7.     else if (this.list == null)
8.     {
9.         this.list = new ListDictionary(this.caseInsensitive ? StringComparer.OrdinalIgnoreCase : null);
10.         this.list.Add(key, value);
11.     }
12.     else if ((this.list.Count + 1) >= 9)
13.     {
14.         //当数据量大于8时，则调用该方法，实例化Hashtable，转移数据，清空list
15.         this.ChangeOver();
16.         this.hashtable.Add(key, value);
17.     }
18.     else
19.     {
20.         this.list.Add(key, value);
21.     }
22. }

复制代码

HybridDictionary类也进一步说明出了链表ListDictionary的特点：相对于Hashtable，占用内存较少，但随着数据量的增加，查询效率远不及Hashtable。
泛型链表-LinkedList

LinkedList是泛型链表，也是用节点存取，节点类型为LinkedListNode ，与ListDictionary的节点不同的是，LinkedListNode有next和prev两个指向，说明LinkedList是双向链表，而ListDictionary是单向链表，代码如下：

1. public sealed class LinkedListNode<T>
2. {
3.     // Fields
4.     internal T item;
5.     internal LinkedList<T> list;
6.     internal LinkedListNode<T> next;
7.     internal LinkedListNode<T> prev;
9.     ......
10. }

复制代码

除了节省内存空间外，链表的另一个优点--插入数据的灵活性，在LinkedList中完全体现出来，共有4个不同位置的添加数据的方法，分别为链头插入，链尾插入，节点前插入，节点后插入。
每种插入方法又分别有两种插入模式：
1、直接插入LinkedListNode，没有返回值。
2、直接插入T类型的值，返回插入完成后的节点。
四种位置，两种模式，一共就有8个插入数据的方法，运用这些方法，可以在添加数据时灵活控制链表中数据的顺序，这个优势是线性表和哈希表所不能比的。代码如下：

1. public LinkedListNode<T> AddAfter(LinkedListNode<T> node, T value);
2. public void AddAfter(LinkedListNode<T> node, LinkedListNode<T> newNode);
3. public void AddBefore(LinkedListNode<T> node, LinkedListNode<T> newNode);
4. public LinkedListNode<T> AddBefore(LinkedListNode<T> node, T value);
5. public void AddFirst(LinkedListNode<T> node);
6. public LinkedListNode<T> AddFirst(T value);
7. public LinkedListNode<T> AddLast(T value);
8. public void AddLast(LinkedListNode<T> node);

复制代码

此外，由于LinkedList是双向链表，在查询数据方面提供了“从前往后”和“从后往前”两个查询方法，所以虽然理论上链表的时间复杂度为O（n），根据自己在插入数据时对顺序的把握，结合这两个方法，可以相对提高查询效率。

1. public LinkedListNode<T> Find(T value);<font color="#9bbb59"><font color="#008040">//从前往后查</font>
2. </font>public LinkedListNode<T> FindLast(T value);<font color="#008080">//从后往前查
3. </font>

复制代码

结论

相对于线性表和哈希表，链表比较节省内存空间。
ListDictionary在每次添加数据时都要遍历链表，效率较低，数据量较大且插入频繁的情况下，不宜选用。
泛型链表LinkedList在保证节省内存空间的同时，在添加数据的顺序方面有极大的灵活性，加上泛型本身避免装箱拆箱的优点，需要用链表的时候，应优先考虑泛型链表。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！