為什么需要哈希表？

舉個例子（摘自漫畫算法）：

在上學時需要學習英語，而在當時有很多的電子詞典，同學們遇到不會的單詞，只要在這個電子詞典上輸入單詞的英文，就可以查出中文的含義。

當時的英語老師強烈反對使用這樣的工具，因為電子詞典查出來的中文資料太有限，而傳統的紙質詞典可以查到單詞的多種含義、詞性、例句等。

但是，同學們還是傾向于使用電子詞典。因為電子詞典實在太方便了，只要輸入要查找的單詞，一瞬間就可以得到結果，而不需要像紙質詞典那樣繁瑣地進行人工查找。

在我們程序員的世界里，往往也需要在內存中存放這樣一個“詞典”，方便我們進行高效的查詢和統計。

例如開發一個學生管理系統，需要有通過輸入學號快速查出對應學生的姓名的功能。這里不必每次都去查詢數據庫，而可以在內存建立一個緩存表，這樣做可以提高查詢效率。

再如我們需要統計一本英文書里某些單詞出現的頻率，就需要遍歷整本書的內容，把這些單詞出現的次數記錄在內存中。

因為這些需求，一個重要的數據結構誕生了，這個數據結構就叫做散列表。

散列表也叫做哈希表，這種數據結構提供了鍵和值的映射關系。只要給出key，就可以高效的查找所對應的值。

那么，散列表是如何根據key來快速查找到所匹配的value呢？

哈希函數

散列表在本質上是一個數組，為什么底層使用數組呢？

數組的特點是它的隨機訪問能力，根據索引來進行訪問，所以我們需要一個“中轉站”，通過某種方式，把鍵轉換為索引，而這個中轉站就叫做哈希函數。

哈希函數.png

那么這個所謂的哈希函數是如何實現的呢？

在不同的語言中，哈希函數的實現方式是不一樣的。這里以Java的常用集合HashMap為例，來看一看哈希函數在Java中的實現。

在Java及大多數面向對象的語言中，每一個對象都有屬于自己的hashcode，這個hashcode是區分不同對象的標識。無論對象自身類型是什么，它們的hashcode都是一個整型變量。

既然都是整型變量，想要轉換成數組的索引也就不難實現了。最簡單的轉換方式就是按照數組的長度進行取模。

通過哈希函數，我們可以把字符串或其他類型的鍵轉換為數組的索引。

例如：給出一個長度為10的數組，當key=24321時，index=HashCode("24321") % Array.length。

哈希表的實現

1、寫操作
寫操作就是在哈希表中插入新的元素。分為兩個步驟：

第一步：通過哈希函數，把key轉化為數組的索引

第二步：如果當前key所對應的索引中沒有元素，就把新元素添加進去。

注意：由于數組的長度是有限的，當插入的元素越來越多，我們很難保證每一個鍵通過哈希函數轉換

為對應不同的索引，在這種情況下，我們不得不處理一個在哈希表中關鍵的問題，兩個不同的鍵，通過哈希函數轉換為同一個索引，這種情況稱為哈希沖突，這也是哈希表中最復雜的。

解決方式：

• 開放尋址法

  開放尋址法很簡單，當一個鍵通過哈希函數轉換為索引并且這個索引已被占用時，我們可以“另謀高就”，尋找下一個空檔的位置。

  例如，newKey通過哈希函數轉換為索引2，該索引在數組中已經被占用了，那么就向后移動一位，看看索引為3的位置是否被占用了，如果占用了，那么繼續向后移動一位，看看索引為4的位置是否被占用了，如果沒有占用，就把key3存放到數組索引為4的索引。

  如圖：

  開放尋址法1.png

  開放尋址法2.png

  開放尋址法3.png

  這就是開放尋址法的基本思路。當然，如果遇到哈希沖突時，尋址方式有很多種，在這里只是簡單的舉個例子。

• 鏈地址法

  鏈地址法說白就是一個鏈表的數組，數組當中每一個元素都是一個鏈表，當遇到哈希沖突時，只需要插入對應的鏈表即可。

2、讀操作

讀操作就是通過給定的鍵，在哈希表中查找對應的值。分為兩個步驟：

第一步：通過哈希函數，把鍵轉換為索引。

第二步：通過索引找到對應的元素，再比較鍵，如果鍵相等，那么就找到了，如果不相等，繼續找。

3、擴容

由于哈希表的底層實際上就是個數組，那么哈希表也就要涉及到擴容的問題了。

首先，什么時候需要進行擴容呢？

當經過多次寫操作時，哈希表達到一定的飽和度時，鍵映射位置發生沖突的概率會逐漸提高。這樣一來，大量的元素擁擠在相同的數組索引位置，會形成很長的鏈表，對后續的寫操作和讀操作的性能會造成很大的影響。這時，哈希表就需要擴展它的長度，也就是進行擴容。

擴容分為兩個步驟：

• 擴容

  創建一個新的數組，并且新的數組的長度是原來的數組的2倍。

• 重新Hash

  遍歷原數組，把所有的元素重新Hash到新數組當中。

注意：在Java中，關于HashMap的實現，在Java8之前HashMap的實現每個位置對應著一個鏈表。不過，從Java8開始有了一個改變，在初始的時候哈希表的每個位置依然是一個鏈表，但是，當哈希沖突達到一定的程度時，會把哈希表中的每一個位置從鏈表轉成紅黑樹！

整體代碼如下（在這里哈希沖突的解決方式使用的是鏈地址法，只不過把鏈表替換為了紅黑樹）：

/**
 * 描述：哈希表（通過紅黑樹解決哈希沖突問題）
 * <p>
 * Create By ZhangBiao
 * 2020/5/12
 */
public class HashTable<K, V> {

    private static final int UPPER_TOL = 10;

    private static final int LOWER_TOL = 2;

    private static final int INIT_CAPACITY = 7;

    private TreeMap<K, V>[] hashtable;

    private int size;

    private int M;

    public HashTable(int M) {
        this.M = M;
        this.size = 0;
        this.hashtable = new TreeMap[M];
        for (int i = 0; i < M; i++) {
            hashtable[i] = new TreeMap<>();
        }
    }

    public HashTable() {
        this(INIT_CAPACITY);
    }

    private int hash(K key) {
        return (key.hashCode() & 0x7fffffff) % M;
    }

    public int getSize() {
        return size;
    }

    public void add(K key, V value) {
        TreeMap<K, V> map = hashtable[hash(key)];
        if (map.containsKey(key)) {
            map.put(key, value);
        } else {
            map.put(key, value);
            size++;
            if (size >= UPPER_TOL * M) {
                resize(2 * M);
            }
        }
    }

    private void resize(int newM) {
        TreeMap<K, V>[] newHashTable = new TreeMap[newM];
        for (int i = 0; i < newM; i++) {
            newHashTable[i] = new TreeMap<>();
        }
        int oldM = this.M;
        this.M = newM;
        for (int i = 0; i < oldM; i++) {
            for (K key : hashtable[i].keySet()) {
                newHashTable[hash(key)].put(key, hashtable[i].get(key));
            }
        }
        this.hashtable = newHashTable;
    }

    public V remove(K key) {
        V ret = null;
        TreeMap<K, V> map = hashtable[hash(key)];
        if (map.containsKey(key)) {
            ret = map.remove(key);
            size--;
            if (size <= LOWER_TOL * M && M > INIT_CAPACITY) {
                resize(M / 2);
            }
        }
        return ret;
    }

    public void set(K key, V value) {
        TreeMap<K, V> map = hashtable[hash(key)];
        if (!map.containsKey(key)) {
            throw new IllegalArgumentException(key + "doesn't exist!");
        }
        map.put(key, value);
    }

    public boolean contains(K key) {
        return hashtable[hash(key)].containsKey(key);
    }

    public V get(K key) {
        return hashtable[hash(key)].get(key);
    }

}