O(logN)，搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

这就是哈希思想的体现。

线性探测的实现

#pragma once
#include <utility>
#include <string>
#include <vector>

using namespace std;
namespace open_address	//闭散列：开放寻址法
{
	enum Status
	{
		DELETE,
		EMPTY,
		EXIST
	};

	template<class K, class V>
	struct HashDate
	{
		pair<K, V> _data;
		Status _status;

	};


	//可以进行int类型的强转
	template<class K>
	struct HashFunc
	{
		size_t operator()(const K& key)		//传入键值，返回哈希值(映射到哈希表的位置)	
		{
			return size_t(key);
		}
	};


	//string类型
	template<>		//模板特化，需要保留<>
	struct HashFunc<string>	//特化成<string>
	{
		size_t operator()(const string& key)		//传入键值，返回哈希值(映射到哈希表的位置)
		{
			// BKDR
			size_t hash = 0;
			for (auto& e : key)
			{
				hash *= 31;
				hash += e;
			}

			return hash;
		}
	};


	template<class K, class V, class HashFunc = HashFunc<K>>
	class HashTable
	{
	public:
		HashTable()
		{
			_t.resize(10);		//初始分配10个HashDate的空间
			_n = 0;
		}

		bool Insert(const pair<K, V>& kv)
		{
			if (Find(kv.first))
				return false;

			if (n * 10 / _t.size() >= 7)	//装载因子大于70%，扩容
			{
				//开一个新表，重新映射
				HashTable<K, V> newtable;
				size_t newsize = _t.size() * 2;	
				newtable._t.resize(newsize);

				//遍历旧表，重新映射
				for (size_t i = 0; i < _t.size(); i++)
				{
					if (_t[i]._status == EXIST)
					{
						newtable.Insert(_t[i]._data);		//调用newtable的Insert
					}
				}

				_t.swap(newtable._t);		//交换表

			}		//先执行扩容，再执行插入，所以不需要++_n

			HashFunc hf;
			size_t hashi = hf(kv.first) %  _t.size();	//除留余数法求哈希值。
														/*要保证哈希值在0~_t.size()-1之间，即需要保证哈希值在可用空间范围之内。
														如果%capacity，可能导致得到的哈希值大于哈希表的最大长度？*/

			while (_t[hashi]._status == EXIST)		//出现碰撞，进行探测
			{
				hashi++;
				hashi %= _t.size();		//循环到头，重新开始,避免无限循环、越界
			}
			
			_t[hashi]._data = data;
			_t[hashi]._status = EXIST;
			_n++;		//键值个数+1
			return true;
		}

		HashDate<K, V>* Find(const K& key)	//1.要么直接找到2.要么出现冲突，再empty之前探测
		{
			HashFunc hf;
			size_t hashi = hf(key) % _t.size();
			
			while (_t[hashi]._status != EMPTY)
			{
				if (_t[hashi]._data.first == key && _t[hashi]._status == EXIST)	//防止伪删除，不能进入DELETE状态查找
					return &_t[hashi];

				hashi++;
				hashi %= _t.size();		//循环到头，重新开始,避免无限循环、越界
			}
			return nullptr;
		}

		//伪删除，只是标记状态为DELETE，不释放空间
		bool Erase(const K& key)
		{
			HashDate<K, V>* ret = Find(key);
			if (ret)	//存在（找不到返回空）
			{
				ret->_status = DELETE;
				_n--;		//键值个数-1(删除需要--_n)
				return true;
			}
			else
				return false;
			
		}

	private:
		vector<HashDate<K, V>> _t;	//闭散列，存储数据
		size_t _n;	//键值的个数
	};

}

代码解读

这段代码实现了一个基于开放寻址法的哈希表，以下是对代码的详细解读：

1. 命名空间和枚举定义

namespace open_address {
	enum Status {
		DELETE,
		EMPTY,
		EXIST
	};

• open_address 命名空间用于包含所有与开放寻址法哈希表相关的类和函数。
• Status 枚举用于表示哈希表中每个槽的状态，包括已删除（DELETE）、空（EMPTY）和存在（EXIST）。

2. 哈希表节点结构体

template<class K, class V>
struct HashDate {
	pair<K, V> _data;
	Status _status;
};

• HashDate 是一个模板结构体，用于表示哈希表中的一个节点，包含一个键值对 _data 和一个状态 _status。

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& key) {
		size_t hash = 0;
		for (auto& e : key) {
			hash *= 31;
			hash += e;
		}
		return hash;
	};
};

• HashFunc 是一个模板结构体，用于生成哈希值。它对 K 类型进行特化，默认实现是将键值转换为 size_t。
• 对于 string 类型，HashFunc 进行了特化，使用 BKDR 哈希算法来生成哈希值。

4. 哈希表类

template<class K, class V, class HashFunc = HashFunc<K>>
class HashTable {
public:
	HashTable() {
		_t.resize(10);
		_n = 0;
	}

	bool Insert(const pair<K, V>& kv) {
		// ...（插入逻辑）
	}

	HashDate<K, V>* Find(const K& key) {
		// ...（查找逻辑）
	}

	bool Erase(const K& key) {
		// ...（删除逻辑）
	}

private:
	vector<HashDate<K, V>> _t;
	size_t _n;
};

• HashTable 是一个模板类，用于实现基于开放寻址法的哈希表。
• 构造函数初始化一个大小为10的 vector 来存储哈希表节点，并设置键值对数量 _n 为0。
• Insert 方法用于插入键值对，如果装载因子超过70%，则进行扩容。
• Find 方法用于查找键值对，如果找到则返回指针，否则返回 nullptr。
• Erase 方法用于删除键值对，实际上是进行伪删除，即将状态设置为 DELETE。
• 私有成员 _t 是一个 vector，用于存储哈希表节点，_n 用于记录当前键值对的数量。

5. 插入、查找和删除逻辑

• 插入逻辑中，如果找到相同的键，则返回 false。如果装载因子超过70%，则进行扩容，然后使用哈希函数找到空槽插入新节点。
• 查找逻辑中，使用哈希函数找到键对应的槽，然后进行线性探测直到找到空槽或匹配的键。
• 删除逻辑中，使用查找逻辑找到节点，然后将其状态设置为 DELETE 并减少键值对数量。

这段代码是一个简单的哈希表实现，它通过开放寻址法解决了哈希冲突，并且提供了基本的插入、查找和删除操作。

二次探测

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