1 基本知識

Hash Table-散列表/雜湊表，是根據關鍵字（key）而直接訪問在記憶體儲存位置的資料結構。它通過一個關鍵值的函式將所需的資料對映到表中的位置來訪問資料，這個對映函式叫做雜湊函式，存放記錄的陣列叫做散列表。
1.1 構造雜湊表的方法
1）直接定址法–取關鍵字的某個線性函式為雜湊地址，Hash（Key）= Key 或 Hash（Key）= A*Key + B，A、B為常數。
2）除留餘數法–取關鍵值被某個不大於散列表長m的數p除後的所得的餘數為雜湊地址。Hash（Key）= Key % P。
3）平方取中法
4）摺疊法
5）隨機數法
6）數學分析法
1.2 雜湊表優缺點

優點：速度快（插入和查詢）
缺點：基於陣列，不能有序的遍歷
鍵值對儲存方式，通過鍵來訪問值
hashMap.put( key , value );
1.3 雜湊衝突和解決方法
雜湊衝突：不同的Key值經過雜湊函式Hash(Key)處理以後可能產生相同的值雜湊地址，我們稱這種情況為雜湊衝突。任意的雜湊函式都不能避免產生衝突。例如：如果碰到兩個不同的關鍵字key1≠key2，但卻有相同的f(key1)=f(key2)，這種現象稱為衝突，並把key1和key2稱為這個雜湊函式的同義詞。
散連結串列的載荷因子
散連結串列的載荷因子定義為：a=填入表的元素個數/散列表的長度
a是散列表裝滿程度的標誌因子，由於表長是定值，a與填入表中的元素個數成正比，a越大，表示填入表中的元素越多，產生衝突的可能性越大；a越小，填入表中的元素越少，產生衝突的可能性越小；散列表的平均查詢長度是載荷因子a的函式，只是不同處理衝突的方法有不同的函式。
對於開放定址法，載荷因子是特別重要的因素，一般限制在0.7-0.8以下。超過時應resize散列表。
解決方法
解決雜湊衝突有兩種方法：
1)開放地址法：1>線性探測2>二次探測

2)鏈地址法
1.4 演算法時間複雜度分析
採用雜湊表作為資料結構的儲存系統中，根據關鍵字的值可快速定位到相應的地址上，在採用開放定址法時僅需O(1)複雜度就可找到，在採用鏈地址法時，需要O(N)複雜度，主要在連結串列中搜索，相對於搜尋樹的O(lg(N))的複雜度，開放定址法顯然來得快，但是雜湊表的長度會變得非常長，採用鏈地址法時快速定位到相應的頭結點中，只需在連結串列中迴圈遍歷即可，程式設計難度比樹降低了不少，還可以將鏈地址法中雜湊表陣列中的指標指向一個樹，這樣在搜尋時，快速定位到搜尋樹的根節點，根據樹的對數搜尋複雜度，更可快速的找到元素,比如說，紅黑樹，B樹..
2 程式碼實現

//HashTable.h
#pragma once
#include<vector>
#include<utility>
#include<string>
namespace OPEN
{
    enum State
    {
        EMPTY = 1,
        EXITS = 2,
        DELETE = 3,
    };

    template<class K, class V>
    struct HashNode
    {
        K _key;
        V _value;
        State   _state;

        HashNode(const K& key = K(), const V& value = V())
            :_key(key)
            , _value(value)
            , _state(EMPTY)
        {}
    };

    template<class K>
    struct Hash
    {
        size_t operator()(const K& key)
        {
            return key;
        }
    };
    template<>
    struct Hash<string>//特化，使得預設時，若調string,則呼叫此函式
    {
        static size_t BKDRHash(const char * str)
        {
            unsigned int seed = 131; // 31 131 1313 13131 131313 
            unsigned int hash = 0;
            while (*str)
            {
                hash = hash * seed + (*str++);
            }
            return (hash & 0x7FFFFFFF);
        }

        size_t operator()(const string& key)
        {
            return BKDRHash(key.c_str());
        }
    };
    template<class K, class V, class _HashFunc = Hash<K>>
    class HashTable
    {
        typedef HashNode<K, V> Node;
    public:
        HashTable()
            :_size(0)
        {}

        size_t HashFunc(const K&key)//取模
        {
            _HashFunc hf;
            return hf(key) % _tables.size();
        }
        void CheckCapacity()
        {
            if (_tables.size() == 0 || _size * 10 / _tables.size() >= 7)//當大於載荷因子，擴容後要重新對映
            {
                size_t newsize = _tables.size() * 2;
                if (newsize == 0)
                {
                    newsize = 10;
                }
                HashTable<K, V, _HashFunc> newht;
                newht._tables.resize(newsize);
                for (size_t i = 0; i < _tables.size(); ++i)
                {
                    if (_tables[i]._state == EXITS)
                    {
                        newht.Insert(_tables[i]._key, _tables[i]._value);
                    }
                }
                _tables.swap(newht._tables);
            }
        }
        bool Insert(const K& key, const V& value)
        {
            CheckCapacity();
            if (Find(key))
            {
                return false;
            }
            size_t i = 1;
            size_t index = HashFunc(key);
            size_t start = index;
            while (_tables[index]._state == EXITS)
            {
                index = start + i*i;
                index = index%_tables.size();
                ++i;
                //++index;//線性探測
                if (index == _tables.size())
                {
                    index = 0;
                }
            }
            _tables[index]._key = key;
            _tables[index]._value = value;
            _tables[index]._state = EXITS;
            _size++;
            return true;
        }
        Node* Find(const K& key)
        {
            size_t index = HashFunc(key);
            size_t start = index;
            int i = 1;
            while (_tables[index]._state != EMPTY)
            {
                if (_tables[index]._key == key)
                {
                    if (_tables[index]._state == EXITS)
                    {
                        return &_tables[index];
                    }
                    else
                    {
                        return NULL;
                    }
                }
                //++index;
                index = start + i*i;
                index = index%_tables.size();
                ++i;
                if (index == _tables.size())
                {
                    index = 0;
                }
            }
            return NULL;
        }

        bool Remove(const K& key)
        {
            Node* node = Find(key);
            if (node)
            {
                node->_state = DELETE;
                --_size;
                return true;
            }
            else
            {
                return false;
            }
        }
    private:
        std::vector<Node> _tables;
        size_t _size;
    };
}

測試程式碼：

//Test.cpp
#include<iostream>
#include<utility>
#include"HashTable.h"
using namespace std;
void TestHashTable()
{
    int a[] = { 89, 18, 49, 58, 9};
    HashTable<int, int> ht;
    for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        ht.Insert(a[i],i);
    }
    HashTable<string, string> dict;
    dict.Insert("sort", "排序");
    dict.Insert("left", "剩餘");
}
int main()
{
    TestHashTable();
    system("pause");
    return 0;
}