数据结构初阶——哈希表的实现（C++）

哈希的相关概念

哈希（Hash）就是将任意长度的输入（包括右字符串或是数据）通过哈希算法转换成固定长度输出的这样一个过程，我们这个输出的通常被称之为哈希值（Hash Value）或是散列值（Hash Code）。

我们在实现我们的平衡树的时候，我们的元素关键码和我们的存储的位置没有什么直接的对应关系，我们在查找一个元素的时候通常需要经过我们的关键码进行多次的比较才能找到对应我们要的值，所以我们在顺序结构中的查找时间复杂度是O(N)，在平衡树里面我们因为树的结构可以做到时间复杂度是O(logN)。

于是我们就在想我们是不是可以在关键码和存储位置中找到一种对应关系类似于我们的数组随机访问呢？

这个显然就是我们的哈希啦，我们可以在关键码和存储位置之间建立对应的映射关系，这样我们的查找效率就会大幅提高。这样的方式就是我们的哈希方法了，哈希方法在实现的时候比较重要的是中间的转换函数的实现，也就是我们讲的哈希函数，通过这个方法构造出来的结构就是我们的哈希表了。

我们这里也来举个栗子：

比如我们的集合是：{1, 3, 5, 6, 8}

我们的哈希函数设置成了：hash(key) = key % capacity，其中我们的capacity就是我们底层空间的总的大小了，我们元素的对应关系如下：

哈希冲突

事实上我们在实现所谓的哈希函数的时候就是减少哈希冲突的过程，哈希冲突就是我们的哈希函数将两个不一样的值映射到了同一个位置，这种现象就是哈希冲突或是哈希碰撞了。

我们这里也来举个栗子：

就结合上面我们的栗子，当我们加入元素13的时候，我们就会发现这个元素映射到了下标3的位置了（13%10 = 3）：

哈希函数

我们首先要知道哈希冲突是不可以避免的（鸽巢原理），但是我们可以设计出比较优秀的哈希函数来减少哈希冲突。
设计的原则：
1、哈希函数的定义域要包括所有的关键码信息。

2、哈希函数计算的结果要尽量均匀分布在整个空间中。

3、哈希函数的设计要简单。

常见的哈希函数如下：

一、直接定址法（常用）

哈希函数：Hash(Key) = A * Key + B。

优点：每个值都有一个唯一对应的值，一次性找到。

缺点：场景比较的局限，通常是整数适用。

使用场景：整数，数据范围比较的集中。

二、除留余数法（常用）

哈希函数：Hash(Key) = Key % p(p <= m)，这里的p就是一个不大于m但是最接近或是等于m的质数。

优点：使用比较的广泛。

缺点：有哈希冲突，冲突越多效率越低。

三、平方取中法

假设我们的关键字是1234，对这个数字开平方得1522756，于是我们取出227作为我们的哈希地址。

使用场景：位数不大的情况。

四、随机数法

我们选择一个随机函数，将关键字放入随机数函数里面得到的值就是我们要的哈希地址了，Hash(Key) = random(Key)。

使用场景：应用在关键字长度不等的时候。

我们这里只是选取了几个比较典型的哈希函数，实际上还是有很多的。

哈希冲突的解决

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

闭散列——开放地址法

闭散列，也就是我们说的开放地址法，也叫蹲坑法，就是说我们的哈希表在没有完全满的时候，我们还是可以将一些出现哈希函数冲突的值放在冲突之后的空位置的，类似我们上次厕所的蹲坑。

而我们的寻找下一个位置也是有很多种的，我们这里重点介绍比较常见的两种方式：

第一种：线性探测法

当我们发生了哈希冲突的时候，我们可以尝试着从发生冲突的位置开始以此向后探测找到一个空的位置。

也就是下面这个式子：

我们这里还是解释一下这几个参数的含义：Hi是我们要找的空位置，H0是我们发生冲突的位置，m就是我们整体表的大小了。

下面我们来举个比较右代表性的栗子：

我们可以发现，随着哈希表中的数据在增加，我们产生的哈希冲突的可能性也在增加。

我们在插入数据的时候会随着数据的增加而导致我们的冲突概率增加，我们在哈希表中引入了负载因子这一衡量参数：

负载因子 = 表里面的数据个数 / 表的大小

负载因子越大，冲突概率越小，增删查打效率越低；相反的，负载因子越小，我们的冲突概率越低，增删查的效率越高。

比如我们将上面的栗子中的表的结构扩充至20，可以明显地看到我们的冲突的概率减少了：

我们知道我们的负载因子越是小，我们的空间利用率就会变低，这个时候我们的很多的空间就会被浪费了。我们一般的会将负载因子控制在0.7~0.8这个区间，超过了0.8我们查表时的cache不命中会按照指数曲线上升。

线性探测的优点：实现起来相对的要简单。

线性探测的缺点：容易产生堆积的现象，也就是我们数据冲突出现在了一起，导致效率降低。

第二种：二次探测

为了然我们产生冲突的数据尽量地不堆在一起，我们找位置的方式就变成了跨步找：

公式如下：

介绍一下这几个参数：

H0：通过哈希函数得到的关键码的位置。

Hi：第二次探测得到的新的存放位置。

m：表的空间大小。

我们还是拿上面的栗子来进行举例子：

我们这里实现的二次探测实际上就是在线性探测的基础上面加大了我们的步长这样做，我们就可以实现哈希表中的元素变得相对稀疏，就不容易造成数据的堆积了。

和上面的线性探测一样我们的二次探测也是可以通过增加表长来减少我们冲突的次数的。

开散列——链地址法

开散列也叫链地址法，也叫拉链法，基本的思路是：对我们的关键码信息集合使用我们的哈希函数计算其对应的哈希地址，将相同地址的关键码合并在一起组成一个桶的结构，也就是我们说的哈希桶，桶里面的元素通过我们的单链表链接起来，然后我们还需要将链表的头节点放在我们的哈希表中（也就是我们第一个索引的元素）。

示意图如下：

图：

闭散列解决了哈希冲突实际上就是规避找空位置这一个问题，相较于闭散列，我们的开散列的不同哈希地址的增删查改的效率是不受我们的冲突影响的，所以我们的开散列的负载因子可以开的更大一些，一般控制在0.0~1.0之间，有的时候可以开到超过1.0。

我们的实际的使用中还是更加推荐使用开散列的方式，原因如下：

1、负载因子更大，空间的利用率可以更高。

2、我们的开散列在极端情况下还有其他的替换结构（红黑树）。

下面这个结构就是我们所说的极端情况了，也就是所以有的元素都放在了一个哈希桶里面，这个时候我们的哈希表的增删查改的时间复杂度就变成了O(N)。

图

这个时候我们可以将我们桶里面的元素维护成一个红黑树的结构，然后将根节点放在表里面，这个时候的增删查改时间复杂度就是O(logN)，这将大大提高我们的效率。

图

这种情况下，就算是我们有十亿个数据在一个桶里面，我们的增删查改的次数也就在30的量级，还是非常快的，这种实现方式我们也形象地称之为“桶里种树”：

在我们的JAVA中，当我们桶里面的数据超过了8个的时候，我们的单链表的结构就会自动变成红黑树的结构，8个以下还是使用单链表。

哈希表的实现

首先就是我们的状态表示，这也是我们哈希表中比较巧妙的设计，具体的状态如下：

1、EMPTY（没有数据的空位置）

2、EXIST（存储了数据）

3、DELETE（原来是有数据的，但是被删除了，这个重点解释）

我们可以采用枚举类型来定义：

struct State {EMPTY,EXIST,DELETE
};

那么我们就要问了，我们为什么要设置这些个状态呢？

实际上，这里就是哈希表设计的巧妙之处，我们先来看看如果我们自己来实现会怎么设计，我们首先想到的可能是下面的这个逻辑：

1、通过我们的哈希函数找到元素x的哈希地址是y。

2、从y下标开始找，找到了就说明存在，反之就不存在了。

但是这里面有个大坑，那就是我们不可能把整个的哈希表都遍历一遍吧，这样我们实现了和没实现是一样的，所以我们正确的做法（目前是这样的）是从我们的y开始找，找到目标或是空位置即可：

图

那么可能你就要问了，为什么是空位置就失败了呢？

首先我们必须要明确一点我们的整个的一个过程都是按照线性探测实现的，找到了空说明之前线性探测的时候这里没有放入值，也就是说x不可能放在后面，因为当前这个空位置它都没放。

但是我们的这种方法还是不可以的：

我们也许会想到将我们的每个位置直接设置成存在和不存在，但是遇到了下面的这种情况，我们还是无能为力了：

样例和图

所以聪明的前人就想到了实现三个状态，也就是在上面状态的基础上加上一个删除状态，表示这里有元素被删除。这样我们在查找的时候遇到了DELETE还是会继续向后遍历的。

总结一下：

当我们查找的时候我们会跳过不匹配的和删除的。

当我们插入的时候我们会插入到状态为EMPTY和DELETE的位置。

于是我们根据上面的内容就有了下面的这个结构：

enum State {EMPTY,DELETE,EXIST
};template <class K, class V>
struct HashDate {pair<K, V> _kv;State _state = EMPTY;
};template <class K, class V>
class HashTable {public:// ...private:vector<HashDate<K, V>> _table;size_t n = 0; // 记录数据的个数
};

哈希表的插入

我们实现的插入步骤如下：

1、首先我们需要查看是否存在该键值的键值对，存在就不用插入了。

2、判断对应的条件是不是满足，判断哈希表的大小和我们的负载因子是不是需要我们来对大小来调整。

3、插入哈希表中，有效个数加一。

其中我们对于条件二的调整如下：

如果是哈希表的大小为0，那么初始化哈希表的大小为10。

如果我们的哈希表的负载因子是大于0.7的，就常见一个新的哈希表，然后将这个哈希表的大小开成原来两倍，之后我们将原来哈希表的元素插入到我们新的哈希表中。

具体的插入过程如下：

1、使用哈希函数计算出来我们具体的哈希地址。

2、产生了哈希冲突，我没就使用线性探测进行插入。

3、将键值对插入，然后将这个位置设置成EXIST。

下面是我们实现插入的代码：

inline unsigned long __stl_next_prime(unsigned long n) {static const int __stl_num_primes = 28;static const unsigned long __stl_prim_list[__stl_num_primes] = {53, 97, 193, 389, 769,1543, 3079, 6151, 12289, 24593,49157, 98317, 196613, 393241, 786433,1572869, 3145739, 6291469, 12582917, 25165843,50331653, 100663319, 201326611, 402653189, 805306457,1610612741, 3221225473, 4294967291};const unsigned long* first = __stl_prim_list;const unsigned long* last = __stl_prim_list + __stl_num_primes;const unsigned long* pos = lower_bound(first, last, n);return pos == last ? *(last - 1) : *pos;
}
bool Insert(const pair<K, V>& kv) {if(Find(kv.first)) {return false;}if(_n * 10 / _table.size() >= 7) {HashTable<K, V> newHashTable;newHashTable._table.resize(__stl_next_prime(_table.size() + 1));for(auto& d : _table) {if(d._state == EXIST) {newHashTable.Insert(d._kv);}}_table.swap(newHashTable._table);}size_t hash0 = kv.first % _table.size(); // 哈希函数的地址size_t hashi = hash0; // 最终的插入位置size_t i = 1;int falg = 1;while(_table[hashi]._state == EXIST) {// 线性探测hashi = (hash0 + i) % _table.size();i++;}_table[hashi]._kv = kv;_table[hashi]._state = EXIST;_n++;return true;
}

哈希表的查找

实现查找主要是下面几个步骤：

1、先判断哈希表是不是空的，空就返回false。

2、通过哈希函数计算出来我们的哈希地址。

3、从哈希地址开始使用线性探测的方法进行数据的查找，知道找到匹配的就返回该地址，找到了EMPTY就返回空指针，找到的位置是DELETE还是继续。

我们的实现代码如下：

HashDate<K, V>* Find(const K& key) {size_t hash0 = key % _table.size();size_t hashi = hash0;size_t i = 1;while(_table[hashi]._state != EMPTY) {if(_table[hashi]._state == EXIST && _table[hashi]._kv.first == key) {return &_table[hashi];}hashi = (hash0 + i) % _table.size();i++;}return nullptr;
}

哈希表的删除

删除哈希表里面的元素还是比较的简单的，我们这里实现的也不是真正意义上的删除，只是在对应的位置打上DELETE的标记即可。删除的步骤如下：
1、判断是不是存在这个键值对，不存在就返回false。

2、存在的话，就将该键值对所在位置的状态设置为DELETE即可。

3、哈希表的有效元素的个数减一。

代码如下：

bool Erase(const K& key) {HashDate<K, V>* pos = Find(key);if(pos) {pos->_state = DELETE;_n--;return true;}return false;
}

哈希表的开散列的实现

哈希表的结构

在开散列结构里面，我们的哈希表实际上存储的是一个一个单链表的头节点。

如下：

template <class K, class V>
struct HashNode {pair<K, V> _kv;HashNode<K, V>* _next;HashNode(const pair<K, V>& kv) : _kv(kv), _next(nullptr) {}
};

和我们上面实现的闭散列的方式不同，我们这里的开散列方式的哈希表是不用存储每个位置的状态的：

template <class K, class V>
class HashTable {typedef HashTable<K, V> Node;public:// ...private:vector<Node*> _table;size_t _n;
};

哈希表的插入

我们这里哈希表的插入的步骤如下：