[C#進階系列]專題二：你知道Dictionary查找速度爲何快嗎？

1、前言

　　在以前有一次面試中，被問到你瞭解Dictionary的內部實現機制嗎？當時只是簡單的了問答了：Dictionary的內部結構是哈希表，從而能夠快速進行查找。可是對於更深一步瞭解就不清楚了。因此面試回來以後，就打算好好研究下Dictionary的源碼。因此也就有了這篇文章。

2、Dictionary源碼剖析

 　　你們都知道，如今微軟已經開源了.NET Framework的源碼了，在線源碼查看地址爲：http://referencesource.microsoft.com/。經過查找能夠找到.NET Framework類的源碼。下面咱們就一塊兒來看下Dictionary源碼。

　　2.1 添加元素

　　首先咱們來查看下Dictionary.Add方法的實現。爲了讓你們更好地實現，下面抽取了Dictionary源碼核心部分來進行分析，詳細的分析代碼以下所示：

// buckets是哈希表，用來存放Key的Hash值
        // entries用來存放元素列表
        // count是元素數量
        private void Insert(TKey key, TValue value, bool add)
        {
            if (key == null)
            {
                throw new ArgumentNullException(key.ToString());
            }
            // 首先分配buckets和entries的空間
            if (buckets == null) Initialize(0);
            int hashCode = comparer.GetHashCode(key) & 0x7FFFFFFF; // 計算key值對應的哈希值(HashCode)
            int targetBucket = hashCode % buckets.Length; // 對哈希值求餘，得到須要對哈希表進行賦值的位置

#if FEATURE_RANDOMIZED_STRING_HASHING
            int collisionCount = 0;
#endif
            // 處理衝突的處理邏輯
            for (int i = buckets[targetBucket]; i >= 0; i = entries[i].next)
            {
                if (entries[i].hashCode == hashCode && comparer.Equals(entries[i].key, key))
                {
                    if (add)
                    {
                        throw new ArgumentNullException();
                    }
                    entries[i].value = value;
                    version++;
                    return;
                }

#if FEATURE_RANDOMIZED_STRING_HASHING
                collisionCount++;
#endif
            }

            int index; // index記錄了元素在元素列表中的位置
            if (freeCount > 0)
            {
                index = freeList;
                freeList = entries[index].next;
                freeCount--;
            }
            else
            {
                // 若是哈希表存放哈希值已滿，則從新從primers數組中取出值來做爲哈希表新的大小
                if (count == entries.Length)
                {
                    Resize();
                    targetBucket = hashCode % buckets.Length;
                }
                // 大小若是沒滿的邏輯
                index = count;
                count++;
            }

            // 對元素列表進行賦值
            entries[index].hashCode = hashCode;
            entries[index].next = buckets[targetBucket];
            entries[index].key = key;
            entries[index].value = value;
            // 對哈希表進行賦值
            buckets[targetBucket] = index;
            version++;

#if FEATURE_RANDOMIZED_STRING_HASHING
            if(collisionCount > HashHelpers.HashCollisionThreshold && HashHelpers.IsWellKnownEqualityComparer(comparer)) 
            {
                comparer = (IEqualityComparer<TKey>) HashHelpers.GetRandomizedEqualityComparer(comparer);
                Resize(entries.Length, true);
            }
#endif
        }

    下面以一個實際的添加例子來具體分析下上面的添加元素代碼，從而更好地理解Add方法的實現原理。

Dictionary<int, string> myDictionary = new Dictionary<int, string>();
            myDictionary.Add(1, "Item 1");
            myDictionary.Add(2, "Item 2");
            myDictionary.Add(3, "Item 3");

    當添加第一個元素時，此時會分配哈希表buckets數組和entries數組的空間和初始大小爲3，分配完成以後，會計算添加元素key值的哈希值，哈希值的計算由具體的哈希算法來實現的，假設1的哈希值爲9的話，此時targetBucket = 9%buckets.Length(3)的值爲0，index的值爲0，則第一個元素存放在entries列表中的第一個位置，最後對哈希表進行賦值，此時賦值的位置爲第0個位置，其值爲index的值，因此爲0，插入第一個元素後Dictionary的內部結構以下所示：

　　後面添加元素的過程依次類推。其原理就是，buckets記錄了元素的在元素列表的存儲位置，也就至關於一個映射列表。在查找的時候，就能夠經過key值的哈希值來與buckets數組長度求餘來得到元素在元素列表中的索引，這樣就能夠快速定位元素的位置，從而得到元素的key對應的Value值。如上面的例子中，若是想找到key值爲1對應的Value值時，此時計算1的哈希值爲9，而後對buckets數組長度求餘，此時得到的值正是0，這樣就能夠直接從entries[0].Value的方式來獲取對應的Value的值，這也就是Dictionary能完成快速查找的實現原理。後面會經過Dictionary內部的查找源碼來證明上面分析的過程。

　　2.2 解決衝突

　　在添加元素過程當中，有一個很重要的問題，若是產生衝突怎麼辦？即若是我後面須要插入的一個元素(假設這個值爲11吧)的key值的哈希值也爲6，此時targetBucket的值也是爲0，但元素列表中0的位置已經存放了元素了，這樣就出現了衝突，那Dictionary是怎樣處理這個衝突的呢？處理衝突的方法有不少種，Dictionary處理的方式是連接法。Dictionary會把發生衝突的元素連接以前元素的後面，經過next屬性來指定衝突關係。此時Dictionary內部結構以下圖所示：

 

3、Dictionary如何實現快速查找呢？

　　針對於Dictionary實現快速查找的緣由，在上面咱們已經作了一個推斷了，下面經過Dictionary內部的代碼實現來驗證下，具體的查找代碼以下所示：

public TValue this[TKey key]
        {
            get
            {
                int i = FindEntry(key);
                // 經過元素所在存在的位置直接獲取其對應的Value
                if (i >= 0) return entries[i].value;
                throw new KeyNotFoundException();
                return default(TValue);
            }
            set
            {
                Insert(key, value, false);
            }
        }

        private int FindEntry(TKey key)
        {
            if (key == null)
            {
                throw new ArgumentNullException();
            }

            if (buckets != null)
            {
                // 得到Key值對應的哈希值
                int hashCode = comparer.GetHashCode(key) & 0x7FFFFFFF;
                // 查找元素在元素列表中的位置，若是沒有衝突的狀況下，此時查找速度爲O(1),存在衝突的狀況下爲O(N),N爲存在衝突的次數
                for (int i = buckets[hashCode % buckets.Length]; i >= 0; i = entries[i].next)
                {
                    if (entries[i].hashCode == hashCode && comparer.Equals(entries[i].key, key)) return i;
                }
            }
            return -1;
        }

    經過代碼能夠看出，咱們以前的分析是完成正確的。從中能夠明白：Dictionary之因此能實現快速查找元素，其內部使用哈希表來存儲元素對應的位置，而後咱們能夠經過哈希值快速地從哈希表中定位元素所在的位置索引，從而快速獲取到key對應的Value值。

4、總結

 　　能夠說，Dictionary的實現原理也是一種空間換時間的思路，多使用一個buckets的存儲空間來存儲元素的位置，從而來提高查找速度。

　　 本文全部×××：DictonaryInDepth.zip