目录
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即 O(log2 N)，搜索的效率取决于搜索过程中元素的比较次数。
是否存在理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。
（一）哈希概念
如果构造一种存储结构**，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立 一一映射的关系，那么在查找时通过该函数可以很快找到该元素。**
当向该结构中：
插入元素时：
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
搜索元素时：
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置 取元素比较，若关键码相等，则搜索成功。
这种存储方式称为哈希：
该方式即为哈希(散列)方法 ，哈希方法中使用的转换函数称为哈希(散列)(hashFunc) 函数，构造出来的结构称 为**哈希表(**Hash Table)(或者称散列表)
哈希冲突
下面为一个哈希表，来模拟哈希冲突的情况，哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。
当我们向表中插入44 时，根据哈希函数应该插入下标为4的位置，但是4的位置已经被占用，所以这种情况下就引发了哈希冲突
哈希冲突：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突 或哈希碰撞。
把具有不同关键码而具有相同哈希地址的数据元素称为"同义词"
注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突
哈希函数
引起哈希冲突的一个原因可能是：哈希函数设计不够合理。
哈希函数设计原则：
- 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间。
-哈希函数计算出来的地址能均匀分布在整个空间中。
-哈希函数应该比较简单。
常见哈希函数：
直接定址法：
取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B
优点：简单、均匀
缺点：需要事先知道关键字的分布情况
使用场景：适合查找比较小且连续的情况
除留余数法：
设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数， 按照哈希函数：Hash(key) = key% p(p将关键码转换成哈希地址）
优点：节省空间
缺点：会引起哈希冲突
（二）哈希冲突解决
解决哈希冲突两种常见的方法是：闭散列 和开散列
i.闭散列（ 开放定址法**）**
闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有 空位置，那么可以把key存放到冲突位置中的"下一个" 空位置中去。
线性探测
在上面模拟的哈希冲突中，44的位置被4给占用而引发的冲突可以用下面的方法解决
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
1.插入：
通过哈希函数获取待插入元素在哈希表中的位置
如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突， 使用线性探测找到下一个空位置，插入新元素
2.删除：
采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素 会影响其他元素的搜索。
比如删除元素4，如果直接删除掉，44查找起来可能会受影 响 。因此线性探测采用标记的伪删除法来删除一个元素。
线性探测缺点：
一旦发生哈希冲突，所有的冲突连在一起，容易产生数据"堆积"，即：不同 关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降 低。
二次探测
为了解决线性探测的缺点，所以有了二次探测，即对哈希表进行扩容，进而减少哈希冲突
研究表明：
当表的长度为质数且表装载因子a不超过0.5时 ，新的表项一定能够插入，而且任 何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题 。在 搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5 ，如果超出 必须考虑增容。
闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。
闭散列哈希表模拟实现:
定义
template<class K> struct HashFunc //哈希函数 { size_t operator()(const K& key) { return (size_t)key; } }; // 哈希表中支持字符串的操作 template<> struct HashFunc<string> { size_t operator()(const string& key) { size_t hash = 0; for (auto e : key) { hash *= 131; hash += e; } return hash; } }; // 以下采用开放定址法，即线性探测解决冲突 namespace open_address { enum State { EXIST, EMPTY, DELETE }; template<class K, class V> struct HashData { pair<K, V> _kv; State _state = EMPTY; }; template<class K, class V, class Hash = HashFunc<K>> class HashTable { public: HashTable() { _tables.resize(10); //resize } bool Insert(const pair<K, V>& kv); HashData<const K, V>* Find(const K& key); bool Erase(const K& key); private: vector<HashData<K, V>> _tables; size_t _n = 0; // 表中存储数据个数 Hash hf; }; }哈希函数(HashFunc)：
这里哈希函数用于将key转换为对应的无符号整数
HashData:
每个表里数据都有一个状态值。 哈希表里的数据默认状态为"EMPTY "；如果插入一个数据，那么该位置的状态就需要更新为"EXIST "，在删除了一个数据之后，需要将该位置的状态设置为"DELETE"。
插入
bool Insert(const pair<K, V>& kv) { //如果插入的值存在则插入失败 if (Find(kv.first)) { return false; } //扩容 if (_n * 10 / _tables.size() >= 7) { HashTable<K, V, Hash> newhs; newhs._tables.resize(_tables.size() * 2); for (int i = 0; i < _tables.size(); i++) { if (_tables[i]._state == EXIST) { newhs.Insert(_tables[i]._kv); } } _tables.swap(newhs._tables); } size_t key = hf(kv.first) % _tables.size(); while (_tables[key]._state == EXIST) { key++; key = key % _tables.size(); } _tables[key]._kv = kv; _tables[key]._state = EXIST; ++_n; return true; }载荷因子 = 表中数据个数 / 表的大小size
当载荷因子>= 7时进行扩容操作（创造一个新表，遍历旧表将旧表的数据插入到新表中，然后交换新旧表的vector）
插入操作即找到状态不是EXIST的位置，进行插入。
查找
HashData<const K, V>* Find(const K& key) { size_t keyi = hf(key) % _tables.size(); while (_tables[keyi]._state != EMPTY) { if (_tables[keyi]._state == EXIST && _tables[keyi]._kv.first == key) { return (HashData<const K, V>*) & _tables[keyi]; } keyi++; keyi %= _tables.size(); } return nullptr; }找到状态不是EMPTY 的位置，然后判断该位置状态是否是EXIST并且该位置的key是否符合。
删除
bool Erase(const K& key) { HashData<const K, V>* ret = Find(key); if (ret) { ret->_state = DELETE; --_n; return true; } return false; }
ii.开散列（链地址法/哈希桶）
开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地 址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链 接起来，各链表的头结点存储在哈希表中。
即下面这种方式：
从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。
开散列哈希表模拟实现
定义
namespace hash_bucket { // KeyOfT: 从T中提取key template<class K> struct MyKeyofT { const K& operator()(const K& key) { return key; } }; template<class K> struct HashFunc { size_t operator()(const K& key) { return (size_t)key; } }; // 哈希表中支持字符串的操作 template<> struct HashFunc<string> { size_t operator()(const string& key) { size_t hash = 0; for (auto e : key) { hash *= 131; hash += e; } return hash; } }; template<class T> struct HashNode { T _data; HashNode<T>* _next; HashNode(const T& data) :_data(data) , _next(nullptr) {} }; // K 为 T 中key的类型 // T 可能是键值对，也可能是K // KeyOfT: 从T中提取key // Hash将key转化为整形，因为哈希函数使用除留余数法 template<class K, class T, class KeyOfT = MyKeyofT<K>, class Hash = HashFunc<K>> class HashTable { typedef HashNode<T> Node; public: HashTable() { _tables.resize(10, nullptr); } // 哈希桶的销毁 ~HashTable() { for (int i = 0; i < _tables.size(); i++) { Node* cur = _tables[i]; while (cur) { Node* next = cur->_next; delete cur; cur = next; } _tables[i] = nullptr; } } // 插入值为data的元素，如果data存在则不插入 bool Insert(const T& data); // 在哈希桶中查找值为key的元素，存在返回true否则返回false bool Find(const K& key); // 哈希桶中删除key的元素，删除成功返回true，否则返回false bool Erase(const K& key); private: vector<Node*> _tables; // 指针数组 size_t _n = 0; // 表中存储数据个数 }; }KeyofT函数：
由于数据是类型T（可能是键值对，也可能是K），所以提供一个KeyofT（从T中提取key），这个函数一般是由unordered容器提供，这里我为了方便理解简单的写了一个。
Hashfuc函数：
将key转换为整形，因为哈希函数使用除留余数法
HashNode：
类似链表结构
插入
bool Insert(const T& data) { KeyOfT KT; //将T转换为 key Hash HF; //将key转换为合适的整数 // 插入值为data的元素，如果data存在则不插入 if (Find(KT(data))) { return false; } //扩容 if (_n == _tables.size()) { vector<Node*> newtables; newtables.resize(_tables.size() * 2, nullptr); for (int i = 0; i < _tables.size(); i++) { Node* cur = _tables[i]; while (cur) { Node* nextNode = cur->_next; size_t hashi = HF(KT(cur->_data)) % newtables.size(); cur->_next = newtables[hashi]; newtables[hashi] = cur; cur = nextNode; } _tables[i] = nullptr; } _tables.swap(newtables); } size_t hashi = HF(KT(data)) % _tables.size(); //链表头插入 Node* newNode = new Node(data); Node* cur = _tables[hashi]; _tables[hashi] = newNode; newNode->_next = cur; ++_n; return true; }扩容：
当荷载因子==1时，进行扩容（创造一个新的vector<Node*>，遍历旧表里每个数据，进行头插操作（类似链表））
查找
// 在哈希桶中查找值为key的元素，存在返回true否则返回false bool Find(const K& key) { KeyOfT KT; //将T转换为 key Hash HF; //将key转换为合适的整数 size_t hashi = key % _tables.size(); Node* cur = _tables[hashi]; while (cur) { if (key == HF(KT(cur->_data))) { return true; } else { cur = cur->_next; } } return false; }删除
// 哈希桶中删除key的元素，删除成功返回true，否则返回false bool Erase(const K& key) { KeyOfT KT; //将T转换为 key Hash HF; //将key转换为合适的整数 //找不到该元素返回false; if (Find(key) == false) { return false; } size_t hashi = HF(key) % _tables.size(); Node* prev = nullptr; Node* cur = _tables[hashi]; while (cur) { if (key == KT(cur->_data)) { //头删除的情况 if (prev == nullptr) { _tables[hashi] = cur->_next; } else { prev->_next = cur->_next; } delete cur; --_n; return true; } prev = cur; cur = cur->_next; } return false; }
总结
开散列（链地址法）与闭散列（开放定址法）对比分析
1. 核心区别
存储结构
闭散列 ：所有元素直接存储在哈希表数组中，冲突时通过探测序列 （如线性探测、二次探测）寻找空槽。例如：
索引=(h(key)+f(i))mod 表大小索引=(h(key)+f(i))mod表大小
其中 f(i)是探测函数。开散列：每个哈希桶（数组槽位）挂载链表或红黑树，冲突元素直接插入对应链表中。
空间占用
- 闭散列要求负载因子较低（如二次探测需 ≤0.7≤0.7），否则探测效率骤降。
- 开散列允许更高负载因子（例如 ≥1≥1），空间利用率更优，但需额外存储链表指针。
2. 性能比较
维度 闭散列 开散列 查找效率 缓存友好，但高负载时探测长度指数增长 链表遍历可能缓存不友好，但可通过红黑树优化 插入/删除 删除需标记"墓碑"，增加复杂度 直接操作链表，删除简单 冲突解决 依赖探测函数设计，易受聚集现象影响 链表自然扩展，冲突处理更灵活 3. 使用场景
闭散列适用场景
- 内存有限且数据量可精准预估
- 需要高缓存命中率的场景（如嵌入式系统）
- 适合静态或低频更新的数据集。
开散列适用场景
- 动态数据（频繁插入/删除）
- 高负载因子环境（如数据库索引）
- 需要简单实现的通用哈希表3。
4. 典型优化
闭散列 ：双重哈希减少聚集，公式：
hi(key)=(h1(key)+i⋅h2(key))mod 表大小hi(key)=(h1(key)+i⋅h2(key))mod表大小
开散列：链表转红黑树（如Java HashMap），将最差查找时间从 O(n) 优化至 O(logn)。