Hash算法：雙重散列

　　雙重散列是線性開型尋址散列（開放尋址法）中的沖突解決技術。雙重散列使用在發生沖突時將第二個散列函數應用於鍵的想法。

　　此算法使用：

　　 　　(hash1(key) + i * hash2(key)) % TABLE_SIZE 

　　來進行雙哈希處理。hash1() 和 hash2() 是哈希函數，而 TABLE_SIZE 是哈希表的大小。當發生碰撞時，我們通過重復增加 步長i 來尋找鍵。

　　第一個Hash函數：hash1(key) = key ％ TABLE_SIZE。

    /**
     * 計算首次的Hash值
     *
     * @param key
     * @return
     */
    private int hash1(int key) {
        return (key % TABLE_SIZE);
    }

　　第二個Hash函數是：hash2(key) = PRIME – (key ％ PRIME)，其中 PRIME 是小於 TABLE_SIZE 的質數。

    /**
     * 發生碰撞是時繼續計算Hash值
     *
     * @param key
     * @return
     */
    private int hash2(int key) {
        return (PRIME - (key % PRIME));
    }

　　第二個Hash函數表現好的特征：

• 絕對不會產生 0 索引

• 能在整個HashTable 循環探測

• 計算會快點

• 與第一個Hash函數互相獨立

• PRIME 與 TABLE_SIZE 是 “相對質數”

　　

Java實現代碼：

package algorithm.hash;

/**
 *  雙重哈希
 */
public class DoubleHash {
    private static final int TABLE_SIZE = 13;   // 哈希表大小
    private static int PRIME = 7;               // 散列函數值

    private int[] hashTable;
    private int curr_size;                      // 當前表中存的元素

    public DoubleHash() {
        this.hashTable = new int[TABLE_SIZE];
        this.curr_size = 0;
        for (int i = 0; i < TABLE_SIZE; i++)
            hashTable[i] = -1;
    }

    private boolean isFull() {
        return curr_size == TABLE_SIZE;
    }

    /**
     * 計算首次的Hash值
     *
     * @param key
     * @return
     */
    private int hash1(int key) {
        return (key % TABLE_SIZE);
    }

    /**
     * 發生碰撞是時繼續計算Hash值
     *
     * @param key
     * @return
     */
    private int hash2(int key) {
        return (PRIME - (key % PRIME));
    }

    /**
     * 向Hash表中存值
     *
     * @param key
     */
    private void insertHash(int key) {
        /* 表是否已滿 */
        if (isFull()) {
            return;
        }

        /* 獲取首次的Hash值 */
        int index = hash1(key);

        // 如果發生碰撞
        if (hashTable[index] != -1) {
            /* 計算第二次的Hash值 */
            int index2 = hash2(key);
            int i = 1;
            while (true) {
                /* 再次合成新的地址 */
                int newIndex = (index + i * index2) % TABLE_SIZE;

                // 如果再次尋找時沒有發生碰撞，把key存入表中的對應位置
                if (hashTable[newIndex] == -1) {
                    hashTable[newIndex] = key;
                    break;
                }
                i++;
            }
        } else {
            // 一開始沒有發生碰撞
            hashTable[index] = key;
        }
        curr_size++;    // Hash表中當前所存元素數量加1
    }

    /**
     * 打印Hash表
     */
    private void displayHash() {
        for (int i = 0; i < TABLE_SIZE; i++) {
            if (hashTable[i] != -1)
                System.out.println(i + " --> " + hashTable[i]);
            else
                System.out.println(i);
        }
    }

    public static void main(String[] args) {
        int[] a = {19, 27, 36, 10, 64};

        DoubleHash doubleHash = new DoubleHash();
        for (int i = 0; i < a.length; i++)
            doubleHash.insertHash(a[i]);

        doubleHash.displayHash();
    }

}