這陣子在重溫資料結構的時候，順便用ILSpy看了一些.NET類庫的實現，發現一些基本的資料結構的實現方法也是挺有意思的，所以這裡拿出來跟大家分享一下。這篇文章討論的是Stack和Queue的泛型實現。
Stack<T>的實現
Stack（棧）是一種後進先出的資料結構，其中最核心的兩個方法分別為Push（入棧）和Pop（出棧）兩個操作，那麼.NET類庫是如何實現這種資料結構呢？為了降低學習成本，這裡將根據.NET原始碼的實現，結合其中的核心設計思想，得出一個簡化版本的實現：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
using System; namespace OriginalCode { /// <summary> /// 基於.NET原始碼的簡化版實現 /// </summary> public class Stack<T> { private const int _defaultCapacity = 4; private T[] _array; private int _size; public Stack() { //預設初始化陣列的數量為空 _array = new T[0]; //初始化陣列的數量為0 _size = 0; } /// <summary> /// 入棧 /// </summary> /// <param name="item">入棧的元素</param> public void Push(T item) { if (_size == _array.Length) { //陣列儲存已經滿了，需重新分配陣列大小 //分配的陣列大小為原來的兩倍 T[] array = new T[_array.Length == 0 ? _defaultCapacity : 2 * _array.Length]; //將原來的陣列Copy到新陣列中 Copy(_array, array); //_array指向新陣列 _array = array; } _array[_size] = item; _size += 1; } /// <summary> /// 出棧 /// </summary> /// <returns>出棧的元素</returns> public T Pop() { if (_size == 0) { throw new Exception("棧為空，當前不能執行出棧操作"); } _size -= 1; T result = _array[_size]; _array[_size] = default(T); return result; } /// <summary> /// 將舊陣列賦值到新陣列(這個方法是一個模擬實現，實際情況.NET原始碼底層用C++實現了更高效的複製) /// </summary> /// <param name="oldArray">舊陣列</param> /// <param name="newArray">新陣列</param> private void Copy(T[] oldArray, T[] newArray) { for (int i = 0; i < oldArray.Length; i++) { newArray[i] = oldArray[i]; } } } } |
必須明確的一點是Stack<T>的底層是靠T[] _array陣列物件維繫著。首先來看建構函式Stack()，這裡做的事情無非就是一些基本的初始化工作，當呼叫這個無參建構函式的時候，會將_array陣列例項化為T[0]，同時將一個_size初始化為0。這個_size主要是用來表示當前棧中存在的元素個數，同時也承擔起類似陣列下標的作用，標識下一個元素入棧的陣列位置。
接下來來看一下Push(T item)函式的實現。這裡的第一步操作其實就是執行一次判斷，判斷當前_array陣列的元素個數是否已經滿了，假如滿了的話，就要對陣列進行擴充。.NET原始碼對於陣列擴充的設計還是比較巧妙的，當_array為空的時候，預設開始分配的陣列個數為4，既new T[4]，假如要插入的是第5個元素的時候，這時陣列的個數不足，就宣告一個新的T[] array，並將個數擴充為_array個數的2倍，之後再將_array元素一個個複製到新的array中，最後將_array欄位指向array，就完成了陣列擴充的工作。這一步在前面的程式碼中的實現應該是很清晰的，不過需要注意的一點是這裡的Copy(_array,array)函式是我自己的一個簡單的實現，跟.NET原始碼中的實現是很不一樣的，.NET原始碼是呼叫一個Array.Copy(this._array, 0, array, 0, this._size)的函式，它的底層應該是用C++實現了陣列複製的更好的優化。通過一張圖來看一下陣列擴容的過程：
最後來看一下Pop()函式的實現。首先先判斷當前陣列的個數是否大於0，小於等於0的話就會丟擲異常。之後就將_size-=1，得到要Pop的物件在陣列的位置。取出_array[_size]後，就呼叫default(T)填充_array[_size]的位置，這樣做的一個好處是取消對原來的物件的引用，是其能夠成為垃圾回收的物件，更好地減少記憶體的佔用。總體而言Pop()實現還是比較簡單的。
從前面我們知道，使用Stack<T>資料結構，陣列擴容應該是影響效能最大的一個因素。預設情況下，假如要往棧中插入100個物件，意味著陣列就要經過4->8->16->32->64->128總共5次的陣列擴容，那麼有沒有什麼辦法可以改善效能呢？答案是有的，.NET原始碼Stack<T>物件除了提供預設的無參建構函式外，還提供了一個Stack(int capacity)的建構函式，capacity引數其實就是用表示來初始化陣列的個數，假如我們能預料到這次插入棧的物件個數的最大值的話（以100為例），就直接這樣呼叫new Stack<T>(100)，這樣就能減少不必要的陣列擴容，從而提高了Stack的使用效能。
Queue<T>的實現
Queue（佇列）是一種先進先出的資料結構，其中最核心的兩個方法是Enqueue（入隊）和Dequeue（出隊）兩個操作。通過前面的熱身，我們已經對Stack<T>的實現比較理解了，其實Queue<T>的實現也有相似的地方，例如底層的資料結構同樣是靠T[] _array陣列物件維繫著，也是使用了2倍陣列擴容的方式。不過，由於佇列具有先進先出的特性，它決定了不能像Stack<T>那樣只用一個_size來維繫棧尾的下標，佇列必須有一個隊頭_head下標和一個隊尾_tail下標來保證先進先出的特性。考慮到佇列的儲存效率，還必須涉及到迴圈佇列的問題，所以Queue<T>的實現會比Stack<T>更為複雜一些，同樣來看一個簡化版本的實現：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 |
using System; namespace OriginalCode { /// <summary> /// 基於.NET原始碼的簡化版實現 /// </summary> public class Queue<T> { private static T[] EMPTY_ARRAY = new T[0]; private const int _defaultCapacity = 4; private T[] _array; private int _head; //頭位置 private int _tail; //尾位置 private int _size; //佇列元素個數 public Queue() { _array = EMPTY_ARRAY; _head = 0; _tail = 0; _size = 0; } public Queue(int capacity) { _array = new T[capacity]; _head = 0; _tail = 0; _size = 0; } /// <summary> /// 入隊操作 /// </summary> /// <param name="item">待入隊元素</param> public void Enqueue(T item) { if (_size == _array.Length) { //確定擴充的容量大小 int capacity = _array.Length * 2; if (capacity < _array.Length + _defaultCapacity) { //.NET原始碼這樣實現的一些基本猜想 //由於可以通過呼叫Queue(int capacity)例項化佇列 capacity可以=1 | 2 | 3 //這裡做與+4做判斷 應該是為了提高基本效能 比如當capacity = 1的時候 *2 = 2 這樣2很快容易有下一次擴充 //不過其實感覺效果並不大 有點設計過度的嫌疑 capacity = _array.Length + _defaultCapacity; } //例項化一個容量更大的陣列 T[] array = new T[capacity]; if (_size > 0) { //當需要重新分配陣列記憶體的時候 根據迴圈佇列的特性 這時的_head一定等於_tail //從舊陣列_array[_head]到_array[_size-1] 複製到 新陣列array[0]...[_size - _head - 1] ArrayCopy(_array, array, 0, _head, _size - _head); //從舊陣列_array[0]到_array[_head-1] 複製到 新陣列array[_size - _head]...[_size - 1] ArrayCopy(_array, array, _size - _head, 0, _head); } _array = array; //將舊陣列指向新陣列 _head = 0; //重新將頭位置定格為0 _tail = _size; //重新將尾位置定格為_size } _array[_tail] = item; _tail = (_tail + 1) % _array.Length; _size += 1; } /// <summary> /// 出隊操作 /// </summary> /// <returns>出隊元素</returns> public T Dequeue() { if (_size == 0) { throw new Exception("當前佇列為空 不能執行出隊操作"); } T result = _array[_head]; _array[_head] = default(T); _head = (_head + 1) % _array.Length; _size -= 1; return result; } /// <summary> /// 將舊陣列的項複製到新陣列(這個方法是一個模擬實現，實際情況.NET原始碼底層用C++實現了更高效的複製) /// </summary> /// <param name="oldArray">舊陣列</param> /// <param name="newArray">新陣列</param> /// <param name="newArrayBeginIndex">新陣列開始項下標</param> /// <param name="oldArrayBeginIndex">舊陣列開始項下標</param> /// <param name="copyCount">複製個數</param> private void ArrayCopy(T[] oldArray, T[] newArray, int newArrayBeginIndex, int oldArrayBeginIndex, int copyCount) { for (int i = oldArrayBeginIndex, j = newArrayBeginIndex; i < oldArrayBeginIndex + copyCount; i++,j++) { newArray[j] = oldArray[i]; } } } } |
首先通過下面的圖來看一下陣列容量足夠的時候，迴圈佇列的執行過程：
基於上面這張圖的執行過程，來看一下Dequeue函式的實現。第一步判斷的是_size是否為0，是的話就丟擲異常。如果當前入隊個數大於0，則獲取_array[_head]元素作為出隊元素，之後就呼叫default(T)填充_array[_head]的位置。由於是一個迴圈佇列的設計，所以不能簡單地將_head+=1，而必須這樣_head=(_head+1)%_array.Length，如上圖所示，_head有可能指向下標為3的位置，假如這時直接_head += 1變為4的話，就跳出了陣列的小標範圍，而_head=(_head+1)%_array.Length變為0，則指向了陣列最前的位置，實現了迴圈佇列的功能，更好地利用了記憶體。
接下來看一下Enqueue(T item)函式的實現。承接上圖的Queue的狀態，假如現在要執行q.Enqueue(“f”)的入隊操作，但是很明顯陣列_array已經滿了，那麼要怎麼辦呢？其實原理和Stack的實現類似，也是要通過陣列擴容的方式，不過比Stack的陣列複製要複雜一些。來繼續看圖：
與Stack<T>一樣，影響Queue<T>效能最大因素是陣列擴容以及相應的陣列複製操作，同樣Queue也提供了一個帶初始化容量的建構函式Queue(int capacity)，如果我們能估算到佇列可能同時存在元素的最大值，就儘量呼叫這個帶capacity的建構函式。