【数据结构】哈希表/散列表

本篇博文，旨在介绍哈希表的基本概念及其用法；介绍了减少哈希冲突的方法；并用代码实现了哈希表的线性探测和哈希桶

哈希表的基本概念

哈希表是一种存储结构，它通过key值可以直接访问该key值在内存中从存储位置；

将关键值映射到表中的位置访问数据，这个映射函数叫做散列函数，存储数据的表叫做散列表；

构造哈希表的几种方法

1、直接定址法

根据关键值直接确定元素存取的位置，该散列函数是一个线性函数；例如 Hash(key) = A*key+B，其中，A和B都为常数

2、除留余数法

取出关键值后，将关键值除以该散列表的长度从而获得的余数，作为散列地址；Hash(key) = key%m

3、平方取中法

取关键字平方后的中间几位为哈希地址。由于一个数的平方的中间几位与这个数的每一位都有关，因而，平方取中法产生冲突的机会相对较小。

平方取中法中所取的位数由表长决定。

例： K = 456 , K2 = 207936 若哈希表的长度m=102，则可取79（中间两位）作为哈希函数值。

4、折叠法

将关键字分割成位数相同的几部分，最后一部分位数可以不同，然后取这几部分的叠加和（去除进位）作为散列地址。数位叠加可以有移位叠加和间界叠加两种方法。 

5、随机数法

选择一随机函数，取关键字的随机值作为散列地址，通常用于关键字长度不同的场合。

6、数学分析法

找出数字的规律，尽可能利用这些数据来构造冲突几率较低的散列地址。

哈希冲突/哈希碰撞

哈希冲突出现的原因

关键值通过任何的散列函数获得的散列地址都有可能是重复的，这种情况叫做哈希冲突；

载荷因子

散列表的载荷因子的定义为：a = 表中的元素个数/散列表的长度

对于开放定址法，载荷因子特别重要，一般情况下严格控制在0.7-0.8

超过0.8，哈希表的效率会很低

过低的话，浪费的空间会更大

任何的散列函数都是无法避免的，在处理哈希冲突的方法中，我们介绍下面两种方法

a 用开放定址法来处理哈希冲突

a1  线性探测

当有需要插入元素的位置已经有元素存在时，则向后遍历寻找空位置

a2  二次探测

当插入位置冲突时，则向后寻找，但不是每次只挪动一个位置，而是冲突次数的平方次（1,4,9....）

b 用开链法处理哈希冲突

哈希桶是一种顺序表和链表的结合体，定义一个数组，数组存储的内容是节点的指针，下面用一个个桶来存储元素；

这样可以提高哈希表的效率

如何减少哈希冲突

a 素数

使用素数做除数可以有效的减少哈希冲突

//素数表
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
};

b 字符串哈希算法

字符串哈希算法就是将一个字符串转化成一个Key值

字符串哈希算法有很多

下面这个链接有详细的介绍

http://www.cnblogs.com/-clq/archive/2012/05/31/2528153.html

代码实现

开放定址法的线性检测

节点的定义：

//定义枚举，表示节点的状态
enum Status
{
	EXIST,
	DELETE,
	EMPTY,
};

//节点的定义
template<typename K,typename V>
struct HashNode
{
	K _key;
	V _value;
	Status _status;

	HashNode(const K& key = K(), const V& value = V())
		:_key(key)
		, _value(value)
		, _status(EMPTY)
	{}
};

状态位标识着这个位置有没有值存在，还是之前存在已被删除

哈希表的定义：

//HashFunc是采用的字符串哈希算法
template<typename K, typename V, typename HashFunc = __HashFunc<K>>
class HashTable
{
	typedef HashNode<K, V> Node;
public:
	//缺省的构造函数
	HashTable()
	{}

	//构造函数
	HashTable(size_t size);

	//将K值转换成哈希值
	size_t HashFunC(const K& key);

	//插入一组值
	pair<Node*, bool> Insert(const K& key,const V& value);

	//查找元素
	Node* find(const K& key);

	//删除一个节点
	void Remove(const K& key);

protected:
	vector<Node> _v;//用vector的下标标志位置
	size_t _size;//哈希表中元素的数量
protected:
	//交换两个哈希表
	void Swap(HashTable<K, V> &h);
	
	//进行容量的判别，进行扩容
	void CheckCapacity();
};

插入函数的实现：

	pair<Node*, bool> Insert(const K& key,const V& value)
	{
		//检查是否需要扩容
		CheckCapacity();

		//对K值进行取余，判断插入的位置
		size_t index = HashFunC(key);

		//如果存在，则循环着继续寻找
		while (_v[index]._status == EXIST)
		{
			index++;
			if (index == _v.size())
				index = 0;
		}

		_v[index]._key = key;
		_v[index]._value = value;
		_v[index]._status = EXIST;

		_size++;

		return make_pair<Node*,bool>(&_v[index] ,true);
	}

插入函数，要找到关键值对应的位置，冲突的话后移；找到后放入对应的Key和value值，并且将状态位改变即可

查找函数的实现：

        Node* find(const K& key)
	{
		//对K值进行取余，判断插入的位置
		size_t index = HashFunC(key);

		//如果存在，则继续寻找
		while (_v[index]._status == EXIST)
		{
			//若相等，判断状态是否是删除
			//若删除，则没找到，返回空
			//若没删除，则返回该位置的地址
			if (_v[index]._key == key)
			{
				if (_v[index]._status == DELETE)
					return NULL;

				return &_v[index];
			}

			index++;
			if (index == _size)
				index = 0;
		}

		return &_v[index];
	}

线性探测中，查找这块有个小问题。当一个关键值是因为冲突后移的话，若后移中的某个值之后删除了，就无法找到这个值了

删除函数的实现：

        void Remove(const K& key)
	{
		//删除仅需要将状态修改
		Node* delNode = find(key);

		if (delNode)
			delNode->_status = DELETE;
	}

先查找是否存在，存在的话只需要将状态位修改成删除即可

扩容函数的实现：

载荷因子超过0.7时，进行扩容

	void CheckCapacity()
	{
		//如果_v为空，则扩容到7
		if (_v.empty())
		{
			_v.resize(_PrimeList[0]);
			return;
		}

		//如果超过载荷因子，则需要扩容
		if (_size*10 / _v.size() >= 7)
		{
			/*size_t newSize = 2 * _v.size();*/

			size_t index = 0;
			while (_PrimeList[index] < _v.size())
			{
				index++;
			}
			size_t newSize = _PrimeList[index];

			//用一个临时变量来存储新生成的哈希表
			//生成完成后，将其和_v交换
			HashTable<K, V> tmp(newSize);
			for (size_t i = 0; i < _v.size(); ++i)
			{
				//如果存在，则将该位置的哈希值插入到临时的哈希表中
				if (_v[i]._status == EXIST)
					tmp.Insert(_v[i]._key,_v[i]._value);
			}
			//交换两个哈希表
			Swap(tmp);
		}
	}

开链法 哈希桶

节点的定义：

//节点的定义
template<class K, class V> 
//struct HushNode  e2:拼写错误，Hash not hush
struct HashNode  
{
	K _key;
	V _value;
	HashNode<K, V>* _next;
	HashNode(const K& key, const V& value)
		:_key(key)
		, _value(value)
		, _next(NULL)
	{}
};

插入函数的实现：

//插入函数的实现
	pair<Node*, bool> Insert(const K& key, const V& value)
	{
		//插入之前要先进行是否扩容的检查
		CheckCapacity();
		//找到这个数的位置
		size_t index = _HushFunc(key);
		Node* cur = _ht[index];
		while (cur)
		{
			if (cur->_key == key)
				return make_pair(cur, false);
			cur = cur->_next;
		}
		Node* temp = new Node(key, value);
		temp->_next = _ht[index];
		_ht[index] = temp;
		return make_pair(temp, true);
	}

用pair可以返回插入成功后节点的指针（或插入失败，相同关键值的指针），以及判断插入成功与否的TRUE或FALSE

删除函数的实现：

	//删除函数的实现
	void Erase(const K& key)
	{
		//先进行查找这个数的位置
		size_t index = _HushFunc(key);
		Node* pre = NULL;
		Node* cur = _ht[index];
		//删除的时候要进行情况的分析讨论
		while (cur)
		{
			if (pre == NULL)
			{
				_ht[index] = cur->_nex;
				delete cur;
			}
			else
			{
				pre->_next = cur->_next;
			}
			cur = cur->_next;

		}
                delete cur;
	}

删除元素的时候，需要分两种情况

a、链上有且仅有该节点

出现这种情况，就是pre为空时，仅需修改vector对应位置存储的指针

b、链上除该节点外，还有多个节点

将cur的指向下一个节点的指针给pre的下一个

查找函数的实现：

	//查找函数的实现
	Node* Find(const K& key)
	{
		for (int i = 0; i<_size; i++)
		{
			Node* cur = _ht[i];
			while (cur)
			{
				if (cur->_key == key)
					return cur;
				cur = cur->_next;
			}
		}
		return NULL;
	}

扩容函数的实现：

	void CheckCapacity()
	{
		//当哈希桶为空的时候或者负载因子为1的时候,进行扩容
		if (_ht.size() == 0 || _size / _ht.size() == 1)
		{
			//建一个新表
			HushTable temp;
			size_t newsize = GetNewSize();
			temp._ht.resize(newsize);

			//将元素放进去
			for (int i = 0; i<_ht.size(); i++)
			{
				Node* cur = _ht[i];
				while (cur)
				{
					temp.Insert(cur->_key, cur->_value);
					cur = cur->_next;
				}
			}
		}
	}

与线性探测不同的是，这里当载荷因子为1的时候进行扩容；

哈希桶的一种极端情况是，所有值都往同一个位置进行插入

如下：

解决方法：

当一个链上的节点数量达到一个百分比（自己定义，可以是100%,50%,10%），则不再存储链表，而是存储一颗红黑树

这一避免出现这种极端情况而带了的弊端

哈希表的github代码链接

https://github.com/haohaosong/DataStruct/blob/master/HashTable.h

哈希桶的github代码链接

https://github.com/haohaosong/DataStruct/blob/master/HashTableBucket.h