【DS】哈希表实现

哈希表的介绍和扩展请查看这篇文章：http://blog.csdn.net/always__/article/details/51584446

基于线性探测，二次探测的哈希表结构，实现字典查询。

代码如下：

#pragma once
#include<iostream>
#include<string>
using namespace std;

命名空间First--线性探测法
//namespace First
//{
//
//enum State
//{
//	EMPTY,
//	DELETE,
//	EXIST,
//};
//
//template<class T>
//class HashTable
//{
//public:
//	HashTable(size_t capacity = 10)
//		:_tables(new T[capacity]),
//		_states(new State[capacity]),
//		_size(0),
//		_capacity(capacity)	
//	{
//		for (size_t i = 0;i < _capacity;++i)
//		{
//			_states[i] = EMPTY;
//		}
//	}
//	~HashTable()
//	{
//		if (_tables)
//		{
//			delete []_tables;
//			delete []_states;
//		}
//	}
//	//拷贝构造函数
//	HashTable(const HashTable<T>& ht)
//		:_tables(NULL)
//		, _status(NULL)
//		,_size(0)
//		,_capacity(0)
//	{
//		HashTable<K> newTables(ht._capacity);
//		for (size_t i = 0; i < ht._capacity; ++i)
//		{
//			if (ht._status[i] == EXITS)
//			{
//				newTables.Insert(ht._tables[i]);
//			}
//		}
//
//		this->Swap(newTables);
//	}
//
//	//重载赋值运算符
//	HashTable<T>& operator=(HashTable<T> ht)
//	{
//		this->Swap(ht);
//
//		return *this;
//	}
//	bool Insert(const T& key)
//	{
//		_CheckCapacity();
//
//		/*if (_size == _capacity)
//		{
//			cout << "HashTable is Full" << endl;
//			return false;
//		}*/
//
//		size_t index = HashFunc(key);
//		//线性探测
//
//		while (_states[index] == EXIST)
//		{
//			if (_tables[index] == key)
//			{
//				return false;
//			}
//
//			++index;
//			if (index == _capacity)
//			{
//				index = 0;
//			}
//		}
//		_tables[index] = key;
//		_states[index] = EXIST;
//		_size++;
//	}
//
//
//
//
//	改进版
//	//bool Insert(const T& key)
//	//{
//	//	_CheckCapacity();
//
//	//	/*if (_size == _capacity)
//	//	{
//	//	cout << "HashTable is Full" << endl;
//	//	return false;
//	//	}*/
//
//	//	size_t index = HashFunc0(key);
//	//	//线性探测
//
//	//	while (_states[index] == EXIST)
//	//	{
//	//		if (_tables[index] == key)
//	//		{
//	//			return false;
//	//		}
//
//	//		index = _HashFunci(index, i++);
//	//		index %= _capacity;
//	//	}
//	//	_tables[index] = key;
//	//	_states[index] = EXIST;
//	//	_size++;
//	//}
//
//
//
//
//
//
//
//	bool Find(const T& key)
//	{
//		size_t index = HashFunc(key);
//		size_t start = index;
//		bool find = false;
//
//		while (_states[index] != EMPTY)
//		{
//			if (_tables[index] == key )
//			{
//				if (_states[index] != DELETE)
//				{
//					return true;
//				}
//				return false;
//			}
//
//			++index;
//			if (index == _capacity)
//			{
//				index = 0;
//			}
//			if (index == start)
//			{
//				return false;
//			}
//		}
//		return false;
//	}
//
//	bool Remove(const T& key)
//	{
//		size_t index = HashFunc(key);
//		size_t start = index;
//
//		while (_states[index] != EMPTY)
//		{
//			if (_tables[index] == key)
//			{
//				_states[index] = DELETE;
//				_size--;
//				return true;
//			}
//
//			++index;
//			if (index == _capacity)
//			{
//				index = 0;
//			}
//			if (index == start)
//			{
//				return false;
//			}
//		}
//	}
//	void Print()
//	{
//		for (size_t i = 0;i < _capacity;++i)
//		{
//			printf("[%d : %d]--\n", _states[i], _tables[i]);
//		}
//		cout << endl;
//	}
//protected:
//	void Swap(HashTable<T> &tmp)
//	{
//		swap(_tables, tmp._tables);
//		swap(_states, tmp._states);
//		swap(_size, tmp._size);
//		swap(_capacity, tmp._capacity);
//	}
//	size_t HashFunc(const T& key)
//	{
//		return key%_capacity;
//	}
//	
//	void _CheckCapacity()
//	{
//		if (_size * 10 / _capacity == 7)
//		{
//			HashTable<T> tmp(2 * _capacity);
//			for (size_t i = 0;i < _capacity;++i)
//			{
//				if (_states[i] == EXIST)
//				{
//					tmp.Insert(_tables[i]);
//				}
//			}
//			this->Swap(tmp);
//		}
//	}
//
//
//protected:
//	T* _tables;			//哈希表
//	State* _states;	    //状态表
//	size_t _size;		//大小
//	size_t _capacity;		
//};
//}
//
//
命名空间Second--闭散列的二次探测
//namespace Second
//{
//	enum State
//	{
//		EMPTY,
//		DELETE,
//		EXIST,
//	};
//
//	template<class T>
//	class HashTable
//	{
//	public:
//		HashTable(size_t capacity = 10)
//			:_tables(new T[capacity]),
//			_states(new State[capacity]),
//			_size(0),
//			_capacity(capacity)
//		{
//			for (size_t i = 0;i < _capacity;++i)
//			{
//				_states[i] = EMPTY;
//			}
//		}
//		~HashTable()
//		{
//			if (_tables)
//			{
//				delete[]_tables;
//				delete[]_states;
//			}
//		}
//		bool Insert(const T& key)
//		{
//			_CheckCapacity();
//			size_t index = HashFunc(key);
//			int i = 1;
//			while (_states[index] ==EXIST)
//			{
//				if (_tables[index] == key)
//				{
//					return false;
//				}
//
//				index = HashFunc(key) + i*i;
//				index %= _capacity;
//				++i;
//
//			}
//
//			_tables[index] = key;
//			_states[index] = EXIST;
//			_size++;
//		}
//		bool Find(const T& key)
//		{
//			
//		}
//
//		bool Remove(const T& key)
//		{
//			
//		}
//		size_t HashFunc(const T& key)
//		{
//			return key%_capacity;
//		}
//		void Print()
//		{
//			for (size_t i = 0;i < _capacity;++i)
//			{
//				printf("[%d : %d]--", _states[i], _tables[i]);
//			}
//			cout << endl;
//		}
//			
//		void _CheckCapacity()
//		{
//			if (_size * 10 / _capacity == 7)
//			{
//				//重新建表
//
//				HashTable<T> tmp(2 * _capacity);
//				for (size_t i = 0;i < _capacity;++i)
//				{
//					if (_states[i] == EXIST)
//					{
//						tmp.Insert(_tables[i]);
//					}
//				}
//				this->Swap(tmp);
//			}
//		}
//		void Swap(HashTable<T> &tmp)
//		{
//			swap(_tables, tmp._tables);
//			swap(_states, tmp._states);
//			swap(_size, tmp._size);
//			swap(_capacity, tmp._capacity);
//		}
//	protected:
//		T* _tables;			//哈希表
//		State* _states;	    //状态表
//		size_t _size;		//大小
//		size_t _capacity;
//	};
//}

//明名空间3--哈希表的key/value形式的二次探测
namespace Third
{
	enum State
	{
		EMPTY,
		DELETE,
		EXIST,
	};

	template<class K, class V>
	struct HashTableNode
	{
		HashTableNode()
		{}
		HashTableNode(const K& key, const V& value)
			:_key(key),
			_value(value)
		{}

		K _key;
		V _value;
	};

	static size_t StringHash(const char* str)
	{
		size_t sum = 0;
		while (*str != '\0')
		{
			sum += *str;
			str++;
		}
		return sum;
	}

	template<class K>
	struct __HashFunc
	{
		size_t operator()(const K& key)
		{
			return key;
		}
	};
	//模板特化
	template<>
	struct __HashFunc<string>
	{
		size_t operator()(const string& str)
		{
			return StringHash(str.c_str());
		}
	};


	template<class K, class V, class HashFunction = __HashFunc<K>>
	class HashTable
	{
		typedef HashTableNode<K, V> Node;
	public:
		HashTable()
			:_tables(NULL)
			, _size(0)
			, _capacity(0)
			, _status(0)
		{}
		HashTable(size_t capacity = 10)
			:_tables(new Node[capacity]),
			_states(new State[capacity]),
			_size(0),
			_capacity(capacity)
		{
			for (size_t i = 0;i < capacity;++i)
			{
				_states[i] = EMPTY;
			}
		}
		~HashTable()
		{
			if (_tables)
			{
				delete[]_tables;
				delete[]_states;
			}
		}

		bool Insert(const K& key, const V& value)
		{
			_CheckCapacity();

			size_t index = HashFunc(key);
			int i = 1;

			//基于二次探测
			while (_states[index] == EXIST)
			{
				if (_tables[index]._key == key)
				{
					return false;
				}

				index = HashFunc(key) + i*i;
				index %= _capacity;
				++i;
			}

			_tables[index] = Node(key, value);
			_states[index] = EXIST;
			++_size;

			return true;
		}
		Node* Find(const K& key)
		{
			size_t index = HashFunc(key);

			size_t start = index;
			int i = 1;
			while (_states[index] != EMPTY)
			{
				if (_tables[index]._key == key)
				{
					if (_states[index] == EXIST)
					{
						return &(_tables[index]);
					}
					return NULL;
				}
				index += i*i;

				if (index >=_capacity)
				{
					index %= _capacity;
				}
				if (index == start)
				{
					break;
				}
			}
			return NULL;
		}

		size_t HashFunc(const K& key)
		{
			HashFunction hf;
			return (hf(key)) % _capacity;
		}
		void Print()
		{
			for (size_t i = 0;i < _capacity;++i)
			{
				cout << "【" << _tables[i]._key<<" --- ";
				cout << _tables[i]._value << "】";
			}
			cout << endl;
		}

	protected:
		void _CheckCapacity()
		{
			if (_size < _capacity)
			{
				return;
			}

			HashTable<K,V,HashFunction> newTable(2 * _capacity);
			for (size_t index = 0;index < _capacity;++index)
			{
				if (_states[index] == EXIST)
				{
					newTable._tables[index] = _tables[index];
					newTable._states[index] = EXIST;
					newTable._size = _size;
				}
			}

			this->Swap(newTable);
		}
		void Swap(HashTable<K, V, HashFunction>& other)
		{
			swap(_tables, other._tables);
			swap(_states, other._states);
			swap(_size, other._size);
			swap(_capacity, other._capacity);
		}
	protected:
		Node* _tables;
		State* _states;
		size_t _size;
		size_t _capacity;
	};

	void TestHashTable()
	{
		HashTable<string, string> ht1(10);

		ht1.Insert("dict", "字典");
		ht1.Insert("hash", "哈希");
		ht1.Insert("function", "函数");
		ht1.Insert("lauyang", "刘阳阳");

		HashTableNode<string, string>* ret = ht1.Find("lauyg");

		if (ret)
		{
			cout << "hash的中文是： " << ret->_value << endl;
		}
		else
		{
			cout << "not exist" << endl;
		}
	}
}

哈希桶实现字典查询：

#pragma once
#include <vector>
#include<iostream>
using namespace std;

//哈希桶key-value结构
namespace BUCKET
{
template<class K,class V>
struct HashTableNode
{
	K _key;
	V _value;
	HashTableNode<K, V>* _next;

	HashTableNode(const K& key, const V& value)
		:_key(key),
		_value(value),
		_next(NULL)
	{}
};

template<class K,class V>
class HashTable
{
	typedef HashTableNode<K, V> Node;
	typedef HashTable<K, V> Table;
public:
	
	HashTable()
		:_size(0)
	{}
	HashTable(size_t capacity)//capacity最好是素数，这样可以减少哈希冲突。
		:_size(0)
	{

 		_tables.resize(_GetNextPrime(capacity));//确保开辟素数大小空间
	}
	~HashTable()
	{
		for (size_t i = 0;i < _tables.size();++i)
		{
			Node* cur = _tables[i];
			while (cur)
			{
				Node*tmp = cur;
				cur = cur->_next;
				delete tmp;
				tmp = NULL;
			}
			_tables[i] = NULL;
		}
		_size = 0;
	}

	HashTable(const Table& other)
		:_size(0)
	{
		Table newTables(other._tables.size());
		newTables._size = other._size;

		for (size_t i = 0;i < other._tables.size();++i)
		{
			Node* cur = other._tables[i];
			Node*& head = newTables._tables[i];

			while (cur)
			{
				//newTables.Insert(cur->_key, cur->_value);

				Node* tmp= new Node(cur->_key, cur->_value);
				tmp->_next = head;
				head = tmp;
				
				cur = cur->_next;
			}
		}
		this->Swap(newTables);
	}

	/*Table& operator=(Table t)
	{
		_tables.swap(t);
		swap(_size, t._size);

		return _tables;
	}*/
	Table& operator=(Table& t)
	{
		if (this != &t)
		{
			Table tmp(t);
			_tables.swap(t);
			swap(_size, t._size);
		}
		

		return _tables;
	}
	
	bool Insert(const K& key, const V& value)
	{
		size_t index = _HashFunc(key,_tables.size());

		//检查是否存在
		Node* cur=_tables[index];
		while (cur)
		{
			if (cur->_key ==key)
			{
				return false;
			}
			cur = cur->_next;
		}

		//头插法
		Node* tmp = new Node(key, value);
		tmp->_next = _tables[index];
		_tables[index] = tmp;

		++_size;
		return true;
	}

	Node* Find(const K& key)
	{
		size_t index = _HashFunc(key, _tables.size());

		Node* cur = _tables[index];
		while (cur)
		{
			if (cur->_key == key)
			{
				return cur;
			}
			cur = cur->_next;
		}
		return NULL;
	}
	bool Remove(const K& key)
	{
		size_t index = _HashFunc(key, _tables.size());
		
		Node* cur = _tables[index];
		if (cur == NULL)
		{
			return false;
		}
		if (cur->_key == key)
		{
			_tables[index] = cur->_next;
			delete cur;
			return true;
		}
		else
		{
			Node* prev = cur;
			cur = cur->_next;
			while (cur)
			{
				if (cur->_key==key)
				{
					prev->_next = cur->_next;
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}
	}
	void Print()
	{
		for (size_t i = 0; i < _tables.size(); ++i)
		{
			printf("tables[%d]->", i);
			Node* cur =_tables[i];
			while (cur)
			{
				cout << "[" << cur->_key << ":" << cur->_value << "]" << "->";
				cur = cur->_next;
			}

			cout << "NULL" << endl;
		}

		cout << endl;
	}
protected:
	size_t _GetNextPrime(size_t size)
	{
		const int _PrimeSize = 28;
		static const unsigned long _PrimeList[_PrimeSize] =
		{
			53ul,         97ul,         193ul,       389ul,       769ul,
			1543ul,       3079ul,       6151ul,      12289ul,     24593ul,
			49157ul,      98317ul,      196613ul,    393241ul,    786433ul,
			1572869ul,    3145739ul,    6291469ul,   12582917ul,  25165843ul,
			50331653ul,   100663319ul,  201326611ul, 402653189ul, 805306457ul,
			1610612741ul, 3221225473ul, 4294967291ul
		};


		for (size_t i = 0; i < _PrimeSize; ++i)
		{
			if (_PrimeList[i] > size)
			{
				return _PrimeList[i];
			}
		}

		return _PrimeList[_PrimeSize - 1];
	}
	size_t _HashFunc(const K& key,size_t capacity)
	{
		return key % capacity;
	}
	void _CheckCapacity()
	{
		//负载值为1时增容
		if (_size == _tables.size())
		{
			size_t nextPrime = _GetNextPrime(_size);

			vector<Node*> newTables;
			newTables.resize(nextPrime);

			for (size_t i = 0;i < _tables.size();++i)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* tmp = cur;
					cur = cur->_next;

					//头插
					size_t index = _HashFunc(tmp->_key, newTables.size());

					tmp->_next = newTables[index];
					newTables[index] = tmp;
				}

				_tables[i] = NULL;
			}

			_tables.swap(newTables);
		}
	}

	
	void Swap(Table &other)
	{
		_tables.swap(other._tables);
		swap(_size,other._size);
	}
private:
	vector<HashTableNode<K, V>*> _tables;
	size_t _size;//Node底下挂多少数据
};


void TestHashBucketTable()
{
	HashTable<int, int> ht(20);
	ht.Insert(1, 14);
	ht.Insert(2, 12);
	ht.Insert(3, 21);
	ht.Insert(4, 11);
	ht.Print();

	//删除remove
	/*ht.Remove(1);
	ht.Print();*/

	//测试拷贝构造
	HashTable<int, int> other(ht);
	other.Print();
	
	//find函数
	/*HashTableNode<int,int>* ret = ht.Find(1);
	if (ret)
	{
		cout<<"the key is exist: "<<ret->_key<<" "<<ret->_value<<endl;
	}
	else
	{
		cout<<"it is not exist"<<endl;
	}*/
}
}
//哈希桶，基于key-value+仿函数的实现
namespace HASHBUCKET
{
	template<class K, class V>
	struct HashTableNode
	{
		K _key;
		V _value;
		HashTableNode<K, V>* _next;

		HashTableNode(const K& key, const V& value)
			:_key(key),
			_value(value),
			_next(NULL)
		{}
	};

	template<class K>
	struct DefaultHashFunc
	{
		size_t operator()(const K& key)
		{
			return key;
		}
	};

	template<>
	struct DefaultHashFunc<string>
	{
		static size_t BKDRHash(const char * str)
		{
			unsigned int seed = 131; // 31 131 1313 13131 131313
			unsigned int hash = 0;
			while (*str)
			{
				hash = hash * seed + (*str++);
			}
			return (hash & 0x7FFFFFFF);
		}
		size_t operator() (const string& key)
		{
			return BKDRHash(key.c_str());
		}
	};
	template<class K, class V,class HashFunc=DefaultHashFunc<K>>
	class HashTable
	{
		typedef HashTableNode<K,V> Node;
		typedef HashTable<K,V,HashFunc> Table;
	public:

		HashTable()
			:_size(0)
		{}
		HashTable(size_t capacity)//capacity最好是素数，这样可以减少哈希冲突。
			:_size(0)
		{

			_tables.resize(_GetNextPrime(capacity));//确保开辟素数大小空间
		}
		~HashTable()
		{
			for (size_t i = 0;i < _tables.size();++i)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node*tmp = cur;
					cur = cur->_next;
					delete tmp;
					tmp = NULL;
				}
				_tables[i] = NULL;
			}
			_size = 0;
		}

		HashTable(const Table& other)
			:_size(0)
		{
			Table newTables(other._tables.size());
			newTables._size = other._size;

			for (size_t i = 0;i < other._tables.size();++i)
			{
				Node* cur = other._tables[i];
				Node*& head = newTables._tables[i];

				while (cur)
				{
					//newTables.Insert(cur->_key, cur->_value);

					Node* tmp = new Node(cur->_key, cur->_value);
					tmp->_next = head;
					head = tmp;

					cur = cur->_next;
				}
			}
			this->Swap(newTables);
		}

		/*Table& operator=(Table t)
		{
		_tables.swap(t);
		swap(_size, t._size);

		return _tables;
		}*/
		Table& operator=(Table& t)
		{
			if (this != &t)
			{
				Table tmp(t);
				_tables.swap(t);
				swap(_size, t._size);
			}


			return _tables;
		}

		bool Insert(const K& key, const V& value)
		{
			size_t index = _HashFunc(key, _tables.size());

			//检查是否存在
			Node* cur = _tables[index];
			while (cur)
			{
				if (cur->_key == key)
				{
					return false;
				}
				cur = cur->_next;
			}

			//头插法
			Node* tmp = new Node(key, value);
			tmp->_next = _tables[index];
			_tables[index] = tmp;

			++_size;
			return true;
		}

		Node* Find(const K& key)
		{
			size_t index = _HashFunc(key, _tables.size());

			Node* cur = _tables[index];
			while (cur)
			{
				if (cur->_key == key)
				{
					return cur;
				}
				cur = cur->_next;
			}
			return NULL;
		}
		bool Remove(const K& key)
		{
			size_t index = _HashFunc(key, _tables.size());

			Node* cur = _tables[index];
			if (cur == NULL)
			{
				return false;
			}
			if (cur->_key == key)
			{
				_tables[index] = cur->_next;
				delete cur;
				return true;
			}
			else
			{
				Node* prev = cur;
				cur = cur->_next;
				while (cur)
				{
					if (cur->_key == key)
					{
						prev->_next = cur->_next;
						delete cur;
						return true;
					}
					prev = cur;
					cur = cur->_next;
				}
				return false;
			}
		}
		void Print()
		{
			for (size_t i = 0; i < _tables.size(); ++i)
			{
				printf("tables[%d]->", i);
				Node* cur = _tables[i];
				while (cur)
				{
					cout << "[" << cur->_key << ":" << cur->_value << "]" << "->";
					cur = cur->_next;
				}

				cout << "NULL" << endl;
			}

			cout << endl;
		}
	protected:
		size_t _GetNextPrime(size_t size)
		{
			const int _PrimeSize = 28;
			static const unsigned long _PrimeList[_PrimeSize] =
			{
				53ul,         97ul,         193ul,       389ul,       769ul,
				1543ul,       3079ul,       6151ul,      12289ul,     24593ul,
				49157ul,      98317ul,      196613ul,    393241ul,    786433ul,
				1572869ul,    3145739ul,    6291469ul,   12582917ul,  25165843ul,
				50331653ul,   100663319ul,  201326611ul, 402653189ul, 805306457ul,
				1610612741ul, 3221225473ul, 4294967291ul
			};


			for (size_t i = 0; i < _PrimeSize; ++i)
			{
				if (_PrimeList[i] > size)
				{
					return _PrimeList[i];
				}
			}

			return _PrimeList[_PrimeSize - 1];
		}
		size_t _HashFunc(const K& key, size_t capacity)
		{
			return HashFunc()(key) % capacity;
		}
		void _CheckCapacity()
		{
			//负载值为1时增容
			if (_size == _tables.size())
			{
				size_t nextPrime = _GetNextPrime(_size);

				vector<Node*> newTables;
				newTables.resize(nextPrime);

				for (size_t i = 0;i < _tables.size();++i)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* tmp = cur;
						cur = cur->_next;

						//头插
						size_t index = _HashFunc(tmp->_key, newTables.size());

						tmp->_next = newTables[index];
						newTables[index] = tmp;
					}

					_tables[i] = NULL;
				}

				_tables.swap(newTables);
			}
		}


		void Swap(Table &other)
		{
			_tables.swap(other._tables);
			swap(_size, other._size);
		}
	private:
		vector<HashTableNode<K, V>*> _tables;
		size_t _size;//Node底下挂多少数据
	};


	void TestHashBucketTable()
	{
		HashTable<string, string> dict(10);
		dict.Insert("字典", "dict");
		dict.Insert("插入", "Insert");
		dict.Insert("删除", "Remove");
		dict.Insert("查找", "Find,Search");
		dict.Print();

		//删除remove
		/*dict.Remove("字典");
		dict.Print();*/

		//测试拷贝构造
		//HashTable<int, int> other(ht);
		//other.Print();

		//find函数
		HashTableNode<string,string>* ret = dict.Find("插入");
		if (ret)
		{
		cout<<"the key is exist: "<<ret->_key<<" : "<<ret->_value<<endl;
		}
		else
		{
		cout<<"it is not exist"<<endl;
		}

	}
}