散列之分离链接法

#include <vector>
#include <list>
#include <string>
#include <algorithm>
using std::vector;
using std::list;
using std::string;
using std::find;

int hash(const string &key)
{
    int hashVal = 0;

    for(string::size_type i=0; i!=key.size(); ++i)
        hashVal += key[i];

    return hashVal;
}
int hash(int key)
{
    return key;
}

template<typename HashedObj>
class HashTable
{
    public:
        explicit HashTable(int size=101):theLists(size) {}

        bool contains(const HashedObj &x) const
        {
            const list<HashedObj> &whichList = theLists[myhash(x)];
            return find(whichList.begin(), whichList.end(), x)!=whichList.end();
        }
        void clear()
        {
            for(int i=0; i<theLists.size(); ++i)
                theLists[i].clear();
        }
        bool insert(const HashedObj &x)
        {
            const list<HashedObj> &whichList = theLists[myhash(x)];

            if(find(whichList.begin(), whichList.end(), x)!=whichList.end())
                return false;

            whichList.push_front(x);
            ++currentSize;
            return true;
        }
        bool remove(const HashedObj &x)
        {
            const list<HashedObj> &whichList = theLists[myhash(x)];
            list<HashedObj>::iterator it = find(whichList.begin(), whichList.end(), x);

            if(it==whichList.end())
                return false;

            whichList.erase(it);
            --currentSize;
            return true;
        }

    private:
        vector<list<HashedObj> > theLists;
        int currentSize;

        int myhash(const HashedObj &x) const
        {
            int hashVal = hash(x);

            hashVal %= theLists.size();
            if(hashVal<0)
                hashVal += theLists.size();

            return hashVal;
        }
};

 以上是分离链接法的C++实现。

除了分离链接法以外，还有一些不使用链表的实现散列表的方法，包括线性探测、平方探测、双散列等。

使用分离链接法，当出现冲突时，直接将新元素插入对应链表即可。不使用链表时，可采用线性探测、平方探测、双散列等技术来处理冲突。

线性探测&平方探测：h(x) = hash(x)+f(i)，其中f(i)分别是i的一次和二次函数。

双散列：h(x) = hash1(x)+f(i)*hash2(x)。

另外，宜使散列表大小为素数值，从而使hash值分布更均匀，以减少冲突。