数据结构—Hashtable(闭散列)

哈希表是常见数据结构中一种拥有高效插入，高效查找的结构，时间复杂度为O(1)。

闭散列哈希的不足之处就是随着冲突的数据增多，插入的效率也会随之变慢，为了优化闭散列哈希的效率，我们可以采取以下的方式：

>1.当插入的数据占总大小的一定比率的时候，也称负载因子，我们可以对哈希表进行扩容，重新通过哈希函数求得位置插入。
>2.我们可以采用素数表的形式，来减少哈希冲突的可能。
>3.通过更好优化的哈希函数，来减少冲突的可能。

每次扩容，带来的也是巨大的开销，首先要开辟新的空间，其次，重新插入需要通过哈希函数重新求得新插入的位置。
1。我们通过对每个哈希节点进行标记，三种标记分别为EMPTY空白，DELETE删除，EXIST存在。分别表示此处没有插入过数据，插入过数据但当前位置数据已经删除，此处存在数据。
2。当我们进行查找的时候，如果前k值通过哈希函数求得位置向后查找，如果为EMPTY则停下，当找到表的尾部，然后从0开始继续查找。
3。当我们插入的时候，同理求得插入位置，如果该位置已经有值，我们向后查找，当遇到EMPTY或者DELETE时，该位置没有数据，在该位置插入。

我们在插入时，通过函数CheckLoadFactor()来检测当前负载因子，当负载因子当到我们设定的比率时，我们采用对哈希表进行扩，扩容的大小为每次素数表中的下一个素数大小。
本次哈希表中的哈希函数，使用的是直接定值法。

#include<iostream>#include<vector>using namespace std;enum condition{    EMPTY,    DELETE,    EXIST,};template<class K, class V>struct Hashnode{    K key;    V value;    condition con;    Hashnode(const K k = K(), const V v = V())        :key(k)        , value(v)        , con(EMPTY)    {}};template<class K>struct HashFun{    size_t operator()(K k)    {        return k;    }};template<class K, class V, class __HashFun = HashFun<K> >class Hashtable{public:    typedef Hashnode<K, V> node;    Hashtable()        :size(0)    {}    Hashtable(const Hashtable& h)        :size(0)    {        for (size_t index = 0; index<h.table.size(); index++)        {            Insert(h.table[index].key, h.table[index].value);        }    }    Hashtable& operator=(Hashtable h)    {        table.swap(h.table);        swap(size, h.size);        return *this;    }    bool Insert(K k, V v)    {        CheckLoadFactor();        size_t index = Hashfun(k);        while (table[index].key = k || (table[index].key = k&&table[index].con != EXIST))        {            if (table[index].con != EXIST)            {                table[index].key = k;                table[index].value = v;                table[index].con = EXIST;                size++;                return true;            }            index++;            if (index>table.size())            {                index = 0;            }        }        return false;    }    size_t Hashfun(const K& k)    {        __HashFun hashfun;        return hashfun(k) % table.size();    }    node* Find(const K& k)    {        size_t index = Hashfun(k);        while (table[index].con != EMPTY)        {            if (table[index].key == k&&table[index].con == EXIST)            {                return &table[index];            }            index++;            if (index>table.size())            {                index = 0;            }        }        return NULL;    }    bool Erase(const K& pos)    {        if (Find(pos) != NULL)        {            Find(pos)->con = DELETE;            size--;            return true;        }        return false;    }private:    void CheckLoadFactor()    {        if (table.size() == 0 || (size * 10 / table.size())>7)        {            table.size() == 0 ? table.resize(7) : Changecapacity();        }    }    void Changecapacity()    {        Hashtable<K, V, __HashFun> newtable;        newtable.table.resize(GetNextPrime(table.size()));        for (size_t index = 0; index<table.size(); index++)        {            if (table[index].con == EXIST)            {                newtable.Insert(table[index].key, table[index].value);            }        }        table.swap(newtable.table);    }    size_t GetNextPrime(size_t pre)    {        const size_t _PrimeSize = 28;        static const unsigned long _PrimeList[_PrimeSize] =        {            53ul, 97ul, 193ul, 389ul, 769ul,            1543ul, 3079ul, 6151ul, 12289ul, 24593ul,            49157ul, 98317ul, 196613ul, 393241ul, 786433ul,            1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,            50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,            1610612741ul, 3221225473ul, 4294967291ul        };        for (size_t index = 0; index<_PrimeSize; index++)        {            if (pre<_PrimeList[index])                return _PrimeList[index];        }        return _PrimeList[_PrimeSize - 1];    }private:    vector<node> table;    size_t size;};