#pragma once
#include<vector>
#include<iostream>
using namespace std;
 
namespace CloseHash
{
	enum State
	{
		EMPTY,   //0 空
		EXIST,   //1  存在
		DELETE,   // 2 已刪除
	};
}

template<class K,class V>
	struct HashData
	{
		pair<K, V> _kv;//數(shù)據(jù)
		State _state = State::EMPTY;//狀態(tài)  --空
	};
	template<class K, class V>//添加仿函數(shù)便于把其他類(lèi)型的數(shù)據(jù)轉(zhuǎn)換為整型數(shù)據(jù)
	class HashTable
	{
 
	public:
		//相關(guān)功能的實(shí)現(xiàn)……
 
	private:
		vector<HashData<K, V>> _table;//哈希表
		size_t _n = 0;//存儲(chǔ)哈希表中有效數(shù)據(jù)的個(gè)數(shù)
	};

//查找
	bool Insert(const pair<K, V>& kv)
	{
		
		size_t hashi = kv.first % _tables.size();    //1.遇到空就停止了
		//線(xiàn)性探測(cè)
		while (_tables[hashi]._state == EXIST)
		{
			hashi++;
			hashi %= _tables.size();    //2. 可能出表
		}
		_tables[hashi]._kv = kv;
		_tables[hashi]._state = EXIST;
		++_n;
		return true;
	}

//查找
	bool Insert(const pair<K, V>& kv)
	{
		if (Find(kv.first))     //插入的值已經(jīng)存在
		{
			return false;
		}
		//擴(kuò)容
		if (_tables.size() == 0 || 10 * _n / _tables.size() >= 7)  //負(fù)載因子
		{
			size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;   //擴(kuò)容
			HashTable<K, V> newHT;
			newHT._tables.resize(newSize);  //擴(kuò)容后用一個(gè)新表
			//遍歷舊表，把舊表每個(gè)存在的元素插入newHT
			for (auto& e : _tables)
			{
				if (e._state == EXIST)
				{
					newHT.Insert(e._kv);
				}
			}
			newHT._tables.swap(_tables);//建立映射關(guān)系后交換
 
		}
		size_t hashi = kv.first % _tables.size();    //1.遇到空就停止了
		//線(xiàn)性探測(cè)
		while (_tables[hashi]._state == EXIST)
		{
			hashi++;
			hashi %= _tables.size();    //2. 可能出表
		}
		_tables[hashi]._kv = kv;
		_tables[hashi]._state = EXIST;
		++_n;
		return true;
	}

//查找
	HashData<K, V>* Find(const K& key)
	{
		if (_tables.size() == 0)
		{
			return nullptr;
		}
		size_t hashi = key % _tables.size();
		while (_tables[hashi]._state != EMPTY)
		{
			if (_tables[hashi]._kv.first == key)
			{
				return &_tables[hashi];   //返回的是地址
			}
			hashi++;
			hashi %= _tables.size();
		}
		return nullptr;
	}
	//刪除
	bool Erase(const K& key)
	{
		HashData<K, V>* ret=Find(key);
		if (ret)
		{
			ret->_state = DELETE;
			--_n;
		}
		else
		{
			return false;
		}
	}

//利用仿函數(shù)將數(shù)據(jù)類(lèi)型轉(zhuǎn)換為整型
template<class K>
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};
//模板的特化
template<>
struct HashFunc<string>  //如果是字符串，直接調(diào)用特化模板
{
	size_t operator()(const string& key)
	{
		
		size_t hash = 0;
		for (auto ch : key)
		{
			hash = hash * 131 + ch;//把所有字符的ascii碼值累計(jì)加起來(lái)
		}
		return hash;
	}
};

#pragma once
#include<vector>
#include<iostream>
using namespace std;
 
enum State
{
	EMPTY,   //0 空
	EXIST,   //1  存在
	DELETE,   // 2 已刪除
};
 
template<class K, class V>
struct HashData
{
	pair<K, V> _kv;//數(shù)據(jù)
	State _state = State::EMPTY;//狀態(tài)  --空
};
//利用仿函數(shù)將數(shù)據(jù)類(lèi)型轉(zhuǎn)換為整型
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 ch : key)
		{
			hash = hash * 131 + ch;//把所有字符的ascii碼值累計(jì)加起來(lái)
		}
		return hash;
	}
};
template<class K, class V,class Hash = HashFunc<K>>
class HashTable
{
 
public:
	//插入
	bool Insert(const pair<K, V>& kv)
	{
		if (Find(kv.first))     //插入的值已經(jīng)存在
		{
			return false;
		}
		//擴(kuò)容
		if (_tables.size() == 0 || 10 * _n / _tables.size() >= 7)  //負(fù)載因子
		{
			size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;   //擴(kuò)容
			HashTable<K, V> newHT;
			newHT._tables.resize(newSize);  //擴(kuò)容后用一個(gè)新表
			//遍歷舊表，把舊表每個(gè)存在的元素插入newHT
			for (auto& e : _tables)
			{
				if (e._state == EXIST)
				{
					newHT.Insert(e._kv);
				}
			}
			newHT._tables.swap(_tables);//建立映射關(guān)系后交換
 
		}
		Hash hf;
		size_t start = hf(kv.first);//取出鍵值對(duì)的key，并且避免了負(fù)數(shù)的情況，借用仿函數(shù)確保是整型數(shù)據(jù)
		start %= _tables.size();
		size_t hashi = start;
		size_t i = 1;
		//1.遇到空就停止了
		//線(xiàn)性探測(cè)
		while (_tables[hashi]._state == EXIST)
		{
			hashi++;
			hashi %= _tables.size();    //2. 可能出表
		}
		_tables[hashi]._kv = kv;
		_tables[hashi]._state = EXIST;
		++_n;
		return true;
	}
	//查找
	HashData<K, V>* Find(const K& key)
	{
		if (_tables.size() == 0)
		{
			return nullptr;
		}
		Hash hf;
		size_t start = hf(key);//通過(guò)仿函數(shù)把其它類(lèi)型數(shù)據(jù)轉(zhuǎn)為整型數(shù)據(jù)
		start %= _tables.size();
		size_t hashi = start;
		size_t i = 1;
		while (_tables[hashi]._state != EMPTY)
		{
			if (_tables[hashi]._kv.first == key)
			{
				return &_tables[hashi];   //返回的是地址
			}
			hashi++;
			hashi %= _tables.size();
		}
		return nullptr;
	}
	//刪除
	bool Erase(const K& key)
	{
		HashData<K, V>* ret=Find(key);
		if (ret)
		{
			ret->_state = DELETE;
			--_n;
		}
		else
		{
			return false;
		}
	}
private:
	vector<HashData<K, V>> _tables;//哈希表
	size_t _n = 0;//存儲(chǔ)哈希表中有效數(shù)據(jù)的個(gè)數(shù)
};
 
 
void testHash1()
{
	int a[] = { 1,11,4,15,26,7 };
	HashTable<int, int> ht;
	for (auto e : a)
	{
		ht.Insert(make_pair(e, e));
	}
}

namespace OpenHash
{
	template<class K>
	struct Hash
	{
		size_t operator()(const K& key)
		{
			return key;
		}
	};
	// 特化
	template<>
	struct Hash < string >
	{
		size_t operator()(const string& s)
		{
			// BKDR Hash
			size_t value = 0;
			for (auto ch : s)
			{
				value += ch;
				value *= 131;
			}
 
			return value;
		}
	};
}

//結(jié)點(diǎn)類(lèi)
	template<class K, class V>
	struct HashNode
	{
		pair<K, V> _kv;
		HashNode<K, V>* _next;
		//構(gòu)造函數(shù)
		HashNode(const pair<K, V>& kv)
			:_kv(kv)
			, _next(nullptr)
		{}
	};
	//哈希表的類(lèi)
	template<class K, class V, class Hash = HashFunc<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		//相關(guān)功能的實(shí)現(xiàn)……
	private:
		//指針數(shù)組
		vector<Node*> _tables;
		size_t _n = 0;//記錄有效數(shù)據(jù)的個(gè)數(shù)
	};

//查找
		Node* Find(const K& key)
		{
			//防止后續(xù)除0錯(cuò)誤
			if (_tables.size() == 0)
			{
				return nullptr;
			}
			//構(gòu)建仿函數(shù)
			HashFunc hf;
			//找到對(duì)應(yīng)的映射下標(biāo)位置
			size_t hashi = hf(key);
			hashi %= _tables.size();
			Node* cur = _tables[hashi];
			//在此位置的鏈表中進(jìn)行遍歷查找
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					//找到了
					return cur;
				}
				cur = cur->_next;
			}
			//遍歷結(jié)束，沒(méi)有找到，返回nullptr
			return nullptr;
		}
		//刪除
		bool Erase(const K& key)
		{
			if (_tables.size() == 0)
			{
				return nullptr;
			}
			size_t hashi = key % _tables.size();
			Node* cur = _tables[hashi];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					//1.頭刪
					if (prev == nullptr)
					{
						_tables[hashi] = cur->_next;
					}
					else    //中間位置刪除
					{
						prev->_next = cur->_next;
					}
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}

//析構(gòu)函數(shù)
		~HashTable()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				_tables[i] = nullptr;//釋放后置空
			}
		}

//插入
		bool Insert(const pair<K, V>& kv)
		{
			//1、去除重復(fù)
			if (Find(kv.first))
			{
				return false;
			}
			//2、負(fù)載因子 == 1就擴(kuò)容
			if (_tables.size() == _n)
			{
				size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				vector<Node*> newTable;
				newTable.resize(newSize, nullptr);
				for (size_t i = 0; i < _tables.size(); i++)//遍歷舊表
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = hf(cur->_kv.first) % newSize;//確認(rèn)映射到新表的位置
						//頭插
						cur->_next = newTable[hashi];
						newTable[hashi] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				newTable.swap(_tables);
			}
			//3、頭插
			//構(gòu)建仿函數(shù)，把數(shù)據(jù)類(lèi)型轉(zhuǎn)為整型，便于后續(xù)建立映射關(guān)系
			HashFunc hf;
			size_t hashi = hf(kv.first);
			hashi %= _tables.size();
			//頭插到對(duì)應(yīng)的桶即可
			Node* newnode = new Node(kv);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return true;
		}