哈希算法：哈希也叫散列、映射，将任意长度的输入通过散列运算转化为固定长度的输出，该输出就是哈希值（散列值）。

哈希映射是一种压缩映射，通常情况下，散列值的空间远小于输入值的空间。

哈希运算的结果称为哈希值，哈希运算是不可逆过程，即不能通过哈希值推算出原值。

哈希运算常用于加密、位图、布隆过滤，位图的作用是海量数据的标记，布隆过滤器的作用是提高海量数据查询的效率（客户端向服务端查询数据）。

一、哈希函数

HashFunc.h

#pragma once
#include <iostream>

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

// 特化
template<>
struct HashFunc<std::string>
{
	size_t operator()(const std::string& str)
	{
		size_t res = 0;
		for (const auto& ch : str)
		{
			res *= 131;	// 随机数取值，避免哈希冲突
			res += ch;
		}
		return res;
	}
};

哈希表：将数据根据哈希运算得到哈希值（关键值），再根据哈希值将数据映射在表中，哈希表通常情况是一个vector容器。哈希表分为闭散列和开散列（哈希桶）。

哈希表的数据增删与红黑树差别不大，各有优劣，但是哈希表的数据查询效率远高于红黑树。

二、闭散列

#define _CRT_SECURE_NO_WARNINGS 1

#pragma
#include <iostream>
#include <vector>
#include "HashFunc.h"

enum status
{
	EMPTY,
	EXIST,
	DELETE
};

template<class K, class V>
struct CloseHashNode
{
	std::pair<K, V> _kv;
	status _status = EMPTY;
};

template<class K, class V, class Hash = HashFunc<K>>
class CloseHash
{
	typedef CloseHashNode<K, V> Data;
public:
	CloseHash()
		: _n(0)
	{
		_table.resize(10);
	}

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

		// 负载因子为0.7
		if (_n * 10 / _table.size() >= 7)
		{
			std::vector<Data> newTable;
			newTable.resize(2 * _table.size());
			for (int i = 0; i < _table.size(); ++i)
			{
				if (_table[i]._status == EXIST)
				{
					size_t pos = Hash()(_table[i]._kv.first) % newTable.size();
					while (newTable[pos]._status != EMPTY)
					{
						pos = (++pos) % newTable.size();
					}
					newTable[pos] = _table[i];
				}
			}
			_table.swap(newTable);
		}

		size_t pos = Hash()(kv.first) % _table.size();
		while (_table[pos]._status != EMPTY)
		{
			pos = (++pos) % _table.size();
		}
		_table[pos]._kv = kv;
		_table[pos]._status = EXIST;
		++_n;
		return true;
	}

	Data* Find(const K& key)
	{
		size_t pos = Hash()(key) % _table.size();
		int cnt = 0;
		while (_table[pos]._status != EMPTY && cnt != _table.size())
		{
			if (key == _table[pos]._kv.first && _table[pos]._status == EXIST)
				return &_table[pos];
			pos = (++pos) % _table.size();
			++cnt;
		}
		return nullptr;
	}

	bool Erase(const K& key)
	{
		Data* ret = Find(key);
		if (ret)
		{
			ret->_status = DELETE;
			--_n;
			return true;
		}
		else
		{
			return false;
		}
	}

private:
	std::vector<Data> _table;
	size_t _n;
};

三、开散列

开散列也称哈希桶，哈希桶的vector节点存储的是数据节点，相同哈希值的节点以链表的形式存储在同一个vector位置上，当节点数与vector容量的比值为平衡因子值(1)时，哈希桶扩容，扩容时重新遍历原表，将原表的元素重新取哈希进行映射，为了提高效率，不拷贝节点，而是改变节点的指向。

#define _CRT_SECURE_NO_WARNINGS 1

#pragma once
#include <iostream>
#include <vector>
#include "HashFunc.h"

template<class K, class V>
struct OpenHashNode
{
	std::pair<K, V> kv;
	OpenHashNode<K, V>* next;
	
	OpenHashNode(const std::pair<K, V>& x)
		: kv(x), next(nullptr)
	{}
};

template<class K, class V, class Hash = HashFunc<K>>
class OpenHash
{
	typedef OpenHashNode<K, V> Node;
public:
	OpenHash()
		: _n(0)
	{
		_table.resize(10, nullptr);
	}

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

		// 检查扩容，平衡因子为 1
		if (_n == _table.size())
		{
			std::vector<Node*> newTable;
			newTable.resize(2 * _table.size(), nullptr);

			for (int i = 0; i < _table.size(); ++i)
			{
				Node* cur = _table[i];
				while (cur)
				{
					Node* next = cur->next;

					size_t pos = Hash()(cur->kv.first) % newTable.size();
					cur->next = newTable[pos];
					newTable[pos] = cur;

					cur = next;
				}
			}

			_table.swap(newTable);
		}

		// 插入新节点
		Node* newNode = new Node(kv);
		size_t pos = Hash()(newNode->kv.first) % _table.size();
		newNode->next = _table[pos];
		_table[pos] = newNode;
		++_n;
		return true;

	}

	Node* Find(const K& key)
	{
		size_t pos = Hash()(key) % _table.size();
		Node* cur = _table[pos];
		while (cur)
		{
			if (cur->kv.first == key)
				return cur;
			cur = cur->next;
		}
		return nullptr;
	}

	bool Erase(const K& key)
	{
		Node* ret = Find(key);
		if (ret)
		{
			size_t pos = Hash()(key) % _table.size();
			Node* cur = _table[pos];
			if (cur == ret)
			{
				cur = ret->next;
				delete ret;
				ret = nullptr;
			}
			else
			{
				while (cur->next != ret)
				{
					cur = cur->next;
				}
				cur->next = ret->next;
				delete ret;
				ret = nullptr;
			}
			--_n;
			return true;
		}
		else
		{
			return false;
		}
	}

private:
	std::vector<Node*> _table;
	int _n;
};

四、测试

#define _CRT_SECURE_NO_WARNINGS 1

#include "CloseHash.h"
#include "OpenHash.h"
using namespace std;

void TestCloseHash()
{
	cout << "CloseHash: " << endl << endl;
	CloseHash<int, int> hash;

	int arr[] = { 34, 36, 12, 54, 5, 22, 65, 32, 13, 4, 1, 52 };
	for (auto& e : arr)
	{
		hash.Insert(make_pair(e, e));
	}

	cout << hash.Find(12) << endl;
	cout << hash.Find(22) << endl;
	cout << hash.Find(32) << endl;
	cout << hash.Find(42) << endl;
	cout << hash.Find(52) << endl;

	cout << endl;
	hash.Erase(32);
	cout << hash.Find(12) << endl;
	cout << hash.Find(22) << endl;
	cout << hash.Find(32) << endl;
	cout << hash.Find(42) << endl;
	cout << hash.Find(52) << endl;
}

void TestOpenHash()
{
	cout << endl << endl << "OpenHash: " << endl << endl;
	OpenHash<int, int> hash;

	int arr[] = { 34, 36, 12, 54, 5, 22, 65, 32, 13, 4, 1, 52 };
	for (auto& e : arr)
	{
		hash.Insert(make_pair(e, e));
	}

	cout << hash.Find(12) << endl;
	cout << hash.Find(22) << endl;
	cout << hash.Find(32) << endl;
	cout << hash.Find(42) << endl;
	cout << hash.Find(52) << endl;

	cout << endl;
	hash.Erase(32);
	cout << hash.Find(12) << endl;
	cout << hash.Find(22) << endl;
	cout << hash.Find(32) << endl;
	cout << hash.Find(42) << endl;
	cout << hash.Find(52) << endl;
}

int main()
{
	TestCloseHash();
	TestOpenHash();

	return 0;
}