【C++】哈希基础1

哈希概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较，顺序查找的时间复杂度为O(N)，平衡树中为树的告诉，搜索的效率取决于搜索过程中元素的比较次数。

所以我们如果想要提高搜索效率，自然就想到要减小比较次数，甚至是有没有一种办法能不经过任何比较，一次直接从表中得到要搜索的元素，这是我们理想中的搜索方法。

那如果构造一种存储结构，通过某种函数使元素的存储位置和它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快的找到该元素。

当向该结构中插入元素时：

• 根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放

当在该结构中搜索元素时：

• 对元素的关键码进行同样的计算，把求得的函数值当作元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功

该方法即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希函数也叫散列函数，构造出来的结构称为哈希表，也叫散列表

哈希函数

当我们的哈希函数设计的不合理的时候，可能会引起哈希冲突。

哈希函数的设计原则：

• 哈希函数的定义域必须包括需要存储的全部关键码，而如果哈希表允许有m个地址，那哈希函数的值域必须在0-m-1之间
• 哈希函数计算出来的地址能均匀的分布在整个空间中
• 哈希函数应该比较简单

常见哈希函数的设计方法有：直接定制法、除留余数法、平方取中法、折叠法、随机数法、数字分析法。

我们最常用的两种方法就是直接定制法和除留余数法。

直接定制法：取关键字的某个线性函数为散列地址：Hash(Key) = A*Key + B，优点：简单且均匀
缺点：需要事先知道关键字的分布情况
使用场景：适合查找比较小且连续的情况

除留余数法：设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(Key) = key%p，将关键码转换成哈希地址。

哈希冲突

哈希冲突：不同的关键字通过相同的哈希函数计算出相同的哈希地址，该种现象称为哈希冲突或者哈希碰撞
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”

哈希冲突的解决方式有两种：开散列和闭散列

闭散列

闭散列法也叫开放地址法，当发生哈希冲突时，如果哈希表未被填满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置的“下一个”空位置中去，关于如何寻找下一个空位置，我们有线性探测法。

线性探测

从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

插入：通过哈希函数获取待插入元素在哈希表中的位置，如果该位置没有元素则直接插入新元素，如果该位置有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素

删除：采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索，因此线性探测采用标记的伪删除法来删除一个元素，意思就是哈希表给每个空间一个标记。

线性探测的缺点：一旦发生了哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。

此时思考一个问题，哈希表在什么情况下进行扩容？如何进行扩容？

哈希表的载荷因子定义为：α = 填入表中的元素个数 / 哈希表的长度。
α是哈希表装满程度的标志因子，由于表长是定值，α与“填入表中的元素个数成正比”，所以α越大，表明填入表中的元素越多，产生冲突的可能性越大，反之，α越小，标明填入表中的元素越少，产生冲突的可能性就越小，实际上，哈希表的平均查找长度是载荷因子α的函数，只是不同处理冲突的方法有不同的函数。

对于开放地址法，载荷因子是特别重要的因素，应严格限制在0.7-0.8以下。研究表明：当表的长度为质数且表装载因子不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次，因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但是在插入时必须确保表的装载因子不超过0.5，如果超出必须考虑增容。

因此：闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

闭散列哈希表的模式实现，代码如下：

enum State { EMPTY, EXIST, DELETE };
//给每个空间一个标记，分别表示空，有元素，元素已被删除
template<class K,class V>
class HashTable
{
	struct Elem
	{
		pair<K, V> _val;
		State _state;
	};
public:
	HashTable(size_t sz) :m_ht(sz), m_size(0)
	{
		for (int i = 0; i < sz; ++i)
		{
			m_ht[i]._state = EMPTY;
			//构造，将哈希表每一个位置都置为空
		}
	}
public:
	void Insert(const pair<K, V> &val)
	{
		//找到哈希位置
		//判断是否为空
		//为空直接插入，不为空线性探测

		size_t hash_idx = Hash(val);
		size_t origin_idx = hash_idx;

		CheckCapacity();//检查容量

		while (m_ht[hash_idx]._state == EXIST)
		{
			hash_idx = (hash_idx + 1) % m_ht.capacity();
			if (hash_idx == origin_idx)//?????
				return;
		}
		Elem e = { val,EXIST };
		m_ht[hash_idx] = e;
		m_size++;
	}

	int Find(const pair<K, V> &key)
	{
		//去该在的哈希位置找
		//找到返回，找不到线性探测找下一个
		size_t hash_idx = Hash(key);
		size_t origin_idx = hash_idx;
		while (m_ht[hash_idx]._state == EXIST && m_ht[hash_idx]._val != key)
		{
			hash_idx = (hash_idx + 1) % m_ht.capacity();
			if (hash_idx == origin_idx)//找一圈没找到返回
				return -1;
		}
		//两种情况跳出循环，都需要考虑
		if (m_ht[hash_idx]._state == EXIST)
			return hash_idx;
		return -1;
	}

	void Remove(const pair<K, V> &key)
	{
		//首先判断是否有key元素，有了再删，没了就不删，直接退出
		int hash_idx = Find(key);

		if (hash_idx != -1)
		{
			m_ht[hash_idx]._state = DELETE;//标记删除
			m_size--;
		}
	}
	//如果在某种结构里面进行了插入或者删除操作，一定记得对计数器进行操作

	int GetNextPrime(int cur_prime)
	{
		static int prime_table[] = { 7,13,19,23,29,43,53,93,103 };
		int n = sizeof(prime_table) / sizeof(prime_table[0]);

		int i;
		for (i = 0; i < n; ++i)
		{
			if (cur_prime == prime_table[i])
				//找到当前的n
				break;
		}
		return i < n ? prime_table[i + 1] : prime_table[n - 1];
	}

	void CheckCapacity()
	{
		if (m_size * 10 / m_ht.capacity() >= 7)//a=0.7
		{
			HashTable<K, V> new_ht(GetNextPrime(m_ht.capacity()));

			for (size_t i = 0; i < m_ht.capacity(); ++i)
			{
				if (m_ht[i]._state == EXIST)
					new_ht.Insert(m_ht[i]._val);
			}
			m_ht.swap(new_ht.m_ht);
		}
	}
public:
	void Show()const
	{
		for (int i = 0; i < m_size; ++i)
		{
			cout << m_ht[i]._val.first;
			cout << " ";
		}
	}
protected:
	size_t Hash(const pair<K, V> &val)
	{
		return val.first % m_ht.capacity();//除留余数法
		//哈希内部元素是vector，可以计算出容量
	}
private:
	vector<Elem> m_ht;
	size_t       m_size;
};
void main()
{
	int ar[] = { 1,9,4,10,8,22,20 };
	int n = sizeof(ar) / sizeof(ar[0]);
	HashTable<int, int> ht(7);
	
	for (int i = 0; i < n; ++i)
	{
		pair<int, int> v = make_pair(ar[i], ar[i]);
		ht.Insert(v);
	}

	//pair<int, int> v = make_pair(15, 15);
	//ht.Insert(v);
	ht.Show(); 
	int idx = ht.Find(make_pair(10,10));

}

开散列

开散列法又叫链地址法，首先对关键码集合利用哈希函数计算哈希地址，具有相同哈希地址的关键码归于同一个子集合，每一个子集称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。每个桶中放的都是发生哈希冲突的元素。

开散列哈希表的模拟实现，代码如下：

template<class Type>
class HashTable;

template<class Type>
class HashNode
{
	friend class HashTable<Type>;
public:
	HashNode(Type d=Type(),HashNode<Type> *n = nullptr):data(d),next(n)
	{}
	~HashNode()
	{}
private:
	Type data;
	HashNode *next;
};

template<class Type>
class HashTable
{
public:
	HashTable()
	{
		memset(m_ht, 0, sizeof(m_ht));
	}
public:
	HashNode<Type>* Find(const Type& key)
	{
		//先去对应的hash位置上进行查找
		//在去对应位置的hash节点进行查找
		size_t idx = Hash(key);
		HashNode<Type> *p = m_ht[idx];
		//当没找到的时候就继续循环
		while (p != nullptr&&key != p->next)
			p = p->next;
		return p;
	}

	void Remove(const Type& key)
	{
		size_t idx = Hash(key);
		HashNode<Type> *p = m_ht[idx];
		if (p == nullptr)
			return;
		
		if (m_ht[idx]->data == key)
			m_ht[idx] = p->next;
		else
		{
			while (p != nullptr&&p->next->data != key)
				p = p->next;//p是要被删除节点的prev节点

			if (p == nullptr)
				return;

			HashNode<Type> *prev = p;
			p = p->next;
			prev->next = p->next;
		}
		delete(p);
	}

	void Insert(const Type& v)
	{
		//找到位置
		size_t idx = Hash(v);
		//插入数据
		HashNode<Type> *node = new HashNode<Type>(v);
		node->next = m_ht[idx];
		m_ht[idx] = node;
	}

	void Show()const
	{
		for (int i = 0; i < HASH_TABLE_SIXE; ++i)
		{
			cout << i << " : ";
			HashNode<Type> *p = m_ht[i];
			while (p != nullptr)
			{
				cout << p->data << "-->";
				p = p->next;
			}
			cout << "Nil." << endl;
		}
	}

protected:
	size_t Hash(const Type &Key)
	{
		return Key % HASH_TABLE_SIXE;
		//除留余数法找到hash位置
	}
protected:
	enum { HASH_TABLE_SIXE = 7 };
private:
	HashNode<Type>* m_ht[HASH_TABLE_SIXE];
};

void main()
{
	int ar[] = { 19,14,23,1,68,20,84,27,55,11,10,79 };
	int n = sizeof(ar) / sizeof(ar[0]);

	HashTable<int> ht;
	for (int i = 0; i < n; ++i)
	{
		ht.Insert(ar[i]);
	}
	ht.Show();

	ht.Remove(1);
	ht.Show();
	
	HashNode<int> *p = ht.Find(20);
}

开散列增容

桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可能会导致一个桶中链表结点非常多，会影响哈希表的性能，因此在一定条件下需要对哈希表进行增容，那在什么情况下进行增容呢？开散列最好的情况是每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容。

开散列与闭散列比较

应用链地址法处理溢出，需要增设链接指针，似乎增加了存储开销。事实上：由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子小于0.7，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间。