哈希表模拟

1.哈希概念

        顺序结构以及平衡树中，元素关键码与其存储位置没有对应关系，因此在查找一个元素时，必须要经过关键码的多次查找。顺序查找时间复杂度为O(N)，平衡树中为树的高度即O(log N)，搜索效率取决于搜索过程中元素的比较次数。

        理想的搜索方法：可以不经过任何比较，一次直接从表中得到想要搜索的元素。

        如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置以及它的关键码之间能够建立一 一映射的关系，那么在查找时通过该函数可以很快找到该元素

当向该结构中：

       插入元素

                根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置经行存放

        搜索元素

                对元素的关键码经行同样的计算，把球的的函数当作元素的存放位置，在结构中按此位置取元素比较，若取关键码相同，则搜索成果

        该方式即为哈希（散列）方法，哈希方法中使用的转换函数称为哈希（散列）函数，构造出来的结构称为哈希表或者散列表

例如：数据集合{1，7，6，4，5，9}；

哈希函数设置为：hash(key) = key % capacity         capacity = 10

用该方法经行搜索不必经行多次关键码的比较，因此搜索的速度比较快 

2.哈希冲突

对于两个元素数据元素的关键字ki，kj 有ki != kj 但是：hash(ki) == hash(kj)

即不同的关键字通过哈希计算出相同的哈希地址，这种现象称为哈希冲突或哈希碰撞

把具有不同的关键码而具有相同的哈希地的元素数据称为“同义词”

3.哈希函数

引起哈希冲突的一个原因可能是：哈希函数设计的不够合理

哈希函数设计原则

        a. 哈希函数的定义域必须包含所需要的存储的关键码，而如果散列表允许有m个地址时，其值域必须在0~m-1之间

        b. 哈希函数计算出来的地址能均匀分布在整个空间中

        c. 哈希函数应该比较简单

常见的哈希函数

1. 直接地址法

        取关键字的某个线性函数为散列地址：hash(key) = A * key + B

        优点：简单、均匀

        缺点：需要事先知道关键字的分布情况

        使用场景：适合查找比较小且连续的情况

2. 除留余数法

        设散列函数中允许的地址为m，取一个不大于m，但最接近m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m)将关键码转换成哈希地址

3. 平方取中法

        假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；

        再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址

        使用场景：不知道关键字的分布，而位数又不是很大的情况

4. 折叠法

        折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这 几部分叠加求和，并按散列表表长，取后几位作为散列地址。

        使用场景：事先不需要知道关键字的分布，适合关键字位数比较多的情况

5. 随机数法

        选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中 random为随机数函数。

        使用场景：通常应用于关键字长度不等时

6. 数学分析法

        设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定 相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只 有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。

例如：

         使用场景：处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况

注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

4.哈希冲突解决

解决哈希冲突的常见方法时：闭散列和开散列

4.1 闭散列

闭散列也叫开放地址法，当发生哈希冲突时，如果哈希表未被装满，说明哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个“空位置中。

寻找下一个空位置的方法

        4.1. 线性探测

                比如，在1中的场景，现在需要插入数据44 ,先通过hashAddr为4，因此44理论上应该插在该位置，但该位置已经插入了4，即发生了哈希冲突

线性探测：从发生冲突的位置开始，依次向后探测，知道寻找到下一个空位置为止。

        4.1.1 插入

                通过哈希函数获取待插入元素在哈希表中的元素位置

                如果该位置没有元素直接插入新元素，如果该位置中有元素发生哈希冲突，

           使用线性探测找到下一个空位置。

        4.1.2 删除

                采用闭散列出列哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除会影响其他元素的搜索 

//哈希表每个位置标记
// EMPTY表示空，EXIST表示有元素，DELETE表示删除
enum state
{
	EMPTY, EXIST, DELETE
};

        4.1.3线性探测的实现

template<class K>
struct HashFunc
{
    size_t operator()(const K& key)
    {
        return (size_t)key;
    }
};

template<>
struct HashFunc <string>
{
    size_t operator()(const string& str)
    {
        size_t hash = 0;
        for (auto& ch : str)
        {
            hash *= ch * 131;
            hash += ch;
        }
        return hash;
    }
};
template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{

public:
    HashTable()
    {
        _tables.resize(10);
    }
    bool Insert(const pair<K, V>& kv)
    {
        if (Find(kv.first)) return false;

        //扩容
        if (_n * 10 / _tables.size() >= 7)
        {
            HashTable<K, V, Hash> newHT;
            newHT._tables.resize(_tables.size() * 2);

            //重新映射新数据
            for (int i = 0; i < _tables.size(); ++i)
            {
                if (_tables[i]._state == EXIST)
                {
                    newHT.Insert(_tables[i]._kv);
                }
            }
            _tables.swap(newHT._tables);
        }

        // 线性探测  
        Hash hs;
        size_t hashi = hs(kv.first) % _tables.size();
        while (_tables[hashi]._state == EXIST)
        {
            hashi++;
            hashi %= _tables.size();
        }
        _tables[hashi]._kv = kv;
        _tables[hashi]._state = EXIST;
        ++_n;
        return true;
    }

    HashData<K, V>* Find(const K& key)
    {
        Hash hs;
        size_t hashi = hs(key) % _tables.size();

        // 线性探测  
        while (_tables[hashi]._state != EMPTY)
        {
            if (_tables[hashi]._kv.first == key && _tables[hashi]._state == EXIST)
                return &_tables[hashi];

            hashi++;
            hashi %= _tables.size();
        }
        return nullptr;
    }

    bool Erase(const K& key)
    {
        HashData<K, V>* ret = Find(key);
        if (ret)
        {
            ret->_state = EMPTY;
            --_n;
            return true;
        }
        else return false;
    }

private:
    vector<HashData<K, V>> _tables;
    size_t _n = 0;

};

哈希因子

        散列表的载荷因子的定义为       a = 填入表中元素个数 / 散列表长的

         a是散列表装满程度的标志因子。由于表长是定值，a与“填入表中元素为”成正比，所以，a越大，标明填入表中元素越多。产生冲突可能性越大；反之，a越小，表明填入表中元素越少，产生冲突可能性越小。

        实际上，散列表的平均查找长的是载荷因子a的函数，只是不同处理冲突的方法有不同的函数。

线性探测的优缺点

优点：实现非常简单。

缺点：一旦发生哈希冲突，所有冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可用的空间位置，使得寻找某些关键码需要多次比较，导致搜索效率降低。

        4.2. 二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位 置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：

hash (key, i) = (hash (key) + i^2) % table_size

研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任 何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在 搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出 必须考虑增容。

因此：闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

4.2 开散列

4.2.1开散列的概念

开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地 址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链 接起来，各链表的头结点存储在哈希表中

从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。

4.2.2开散列的实现

template<class K>
struct HashFunc
{
    size_t operator()(const K& key)
    {
        return (size_t)key;
    }
};

template<>
struct HashFunc <string>
{
    size_t operator()(const string& str)
    {
        size_t hash = 0;
        for (auto& ch : str)
        {
            hash *= ch * 131;
            hash += ch;
        }
        return hash;
    }
};
template<class K, class V>
class HashData
{
    HashData(const pair<K, V>& kv)
        :_kv(kv)
    {}

    pair<K, V> _kv;
    HashData<K, V>* _next = nullptr;
};

template<class K, class V, class Hash = HashFunc<K>>
class HashTable
{
    typedef HashData<K, V> Node;
public:
    HashTable()
    {
        _tables.resize(10, nullptr);
    }
    bool Insert(const pair<K, V>& kv)
    {
        if (Find(kv.first)) return false;

        //扩容
        if (_n == _tables.size)
        {
            HashTable<K, V, Hash> newHT;
            newHT._tables.resize(2 * _tables.size(), nullptr);

            for (int i = 0; i < _tables.size(); ++i)
            {
                Node* cur = _tables[hashi];
                while (cur)
                {
                    size_t hashi = hs(cur->_kv.first) & newHT._tables.size();
                    Node* next = cur->_next;
                    cur->_next = newHT._tables[hashi];
                    newHT._tables[hashi] = cur;

                    cur = next;
                }
                _tables[i] = nullptr;
            }
        }

        Node* newnode = new Node(kv);
        Hash hs;
        size_t hashi = hs(kv.first) % _tables.capacity();

        //头插
        newnode->_next = _tables[hashi];
        _tables[hashi] = newnode;

        _n++;
        return true;
    }

    bool Erase(const K& key)
    {
        Hash hs;
        size_t hashi = hs(key) % _tables.size();
        Node* parent = nullptr;
        Node* cur = _tables[hashi];

        while (cur)
        {
            if (cur->_kv.first == key)
            {
                if (parent == nullptr) _tables[hashi] = cur->_next;
                else parent->_next = cur->_next;

                delete cur;
                return true;
            }
            else
            {
                parent = cur;
                cur = cur->_next;
            }
        }

        return false;
    }
    Node* Find(const K& key)
    {
        Hash hs;
        size_t hashi = hs(key) % _tables.size();
        Node* cur = _tables[hashi];
        while (cur)
        {
            if (cur->_kv.first == key)
            {
                return cur;
            }
            else cur = cur->_next;
        }
        return false;
    }
private:
    vector<Node*> _tables;  //指针数组
    size_t _n = 0;
};

4.2.3开散列的扩容 

桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可 能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希 表进行增容，那该条件怎么确认呢？

开散列最好的情况是：每个哈希桶中刚好挂一个节点， 再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可 以给哈希表增容。

开散列与闭散列的比较

应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事实上： 由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子a <= 0.7，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间。

//扩容
if (_n == _tables.size)
{
    HashTable<K, V, Hash> newHT;
    newHT._tables.resize(2 * _tables.size(), nullptr);

    for (int i = 0; i < _tables.size(); ++i)
    {
        Node* cur = _tables[hashi];
        while (cur)
        {
            size_t hashi = hs(cur->_kv.first) & newHT._tables.size();
            Node* next = cur->_next;
            cur->_next = newHT._tables[hashi];
            newHT._tables[hashi] = cur;

            cur = next;
        }
        _tables[i] = nullptr;
    }
}