哈希表(散列表)介绍

目录

前言

一.哈希概念

        1.1 什么时哈希表

        1.2 哈希函数

        1.3 哈希冲突

        1.4 哈希冲突的解决

                1.4.1 闭散列

               1.4.2 开散列

                1.4.3 问题       

---

前言

        哈希表时C++11两容器unordered_set和unordered_map的底层结构。它的搜索的时间复杂度为O(1)，常数次。

一.哈希概念

        1.1 什么时哈希表

        哈希表时保存数据的表。通过哈希函数使得数据和存储位置之间建立一一对应的映射关系。在查找时，通过哈希函数可以直接找到该元素。

        1.2 哈希函数

        常见的哈希函数

• 直接定址法(常用)

        取关键字的某个线性函数来得到存储位置：Hash(key) = A*key + B。key为数据值，Hash(key)为在哈希表中保存的位置。

        优点：简单，均匀，没有哈希冲突

        缺点：数据量小，数据差值大，需要开辟的空间大，但是使用空间少，浪费空间。

        一般数据和保存位置之间是直接或者间接相关的。

        如：保存小写字符：直接开辟一个大小为26字节的数组，按照字符a保存在0好下标位置，b保存在1好下标位置的顺序保存。间接相关。

        保存所有字符：直接开辟一个大小为256字节的数组，按照字符ASCII码值，直接保存，直接相关。     

        使用场景：数据量小且数据连续情况。

• 除留余数法(常用)

        取哈希表中允许保存数据的个数，即哈希表的容量m，去一个不大于m的数，但是接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key % p(p<=m)，key为数据值，Hash(key)为在哈希表中保存的位置。一般p就取哈希表的大小m。

• 平方取中法(了解)

        将一个数平法后取中间的3位作为哈希地址(保存位置)。

• 折叠法(了解)

        折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
        折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况

• 随机数法(了解)

        选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。
        通常应用于关键字长度不等时采用此法

• 数学分析法(了解)

        设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。

        就是找一些在一串数字中，取与其他都不同的几位数字，可以代表该数字作为保存位置。如身份证号，手机号。

        1.3 哈希冲突

        对于不同的数据，通过相同哈希函数得到在哈希表中保存的位置相同，该现象称为哈希冲突。

        引起哈希冲突的原因可能是哈希函数设计得不够合理，但是，不管怎么优化哈希函数，只能降低哈希冲突的可能性，哈希冲突都是无法避免的。

        1.4 哈希冲突的解决

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

                1.4.1 闭散列

        闭散列也叫开发定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然有空位置，那么可以把数据保存到冲突位置的下一个空位置中。(占用别的数据的位置)

 如何寻找下一个空位置？

        1. 线性探测

• 插入

        通过哈希函数获取插入位置

        如果该位置没有元素，直接插入新元素。如果有元素，发生哈希冲突，在冲突位置顺序往后找下一个空位置，插入新元素。

• 删除

        通过线性探测插入元素，我们知道哈希冲突的元素，一定会保存在保存位置的连续且不为空的位置，意思就是找哈希冲突的数据时，往哈希冲突位置往后找到为空位置截至。所以删除数据时，不能随便删除数据。如下：

 因此线性探测采用标记的伪删除来删除一个元素，就是哈希表中保存的是一个结构体，结构以里有一个变量保存数据，一个变量了代表当前位置的状态。

//状态
enum State{	
    EXIT,//存在元素
	DELETE,//该位置为删除状态
	EMPTY,//该位置为空，不存在元素
};
//保存的元素类型
struct Ele{
	T _data;//数据
	State _state = EMPTY;//状态
};

        线性探测缺点：一旦发生哈希冲突，所有冲突的数据都会连在一起保存，容易产生数据堆积，此时插入一数据时，可能一段位置全被占用了，一直要找空位置，导致效率降低。

         2.二次探测

        针对线性探测导致冲突数据堆积的缺点，二次探测找空位置的方法是：

Hi = (H0 + i * i) % capacity，H0是一开始数据保存的位置，也就是冲突位置，Hi查找的空位置。这样查找可以使得冲突数据位置的错开的。

问题：哈希表什么情况下进行扩容？如何扩容？

        这里得介绍一个负载因子的定义：负载因子 = 填入表中的元素个数 / 哈希表的长度

        负载因子是哈希表装满的标志因子，由于表长是定值，负载因子与填入标志元素的个数成正比，所以负载因子越大，填入表中的元素个数越多，产生冲突的可能性越大，反之，负载因子越小，填入表中的元素个数越少，产生冲突的可能性越小。

        对于闭散列，负载因子是一个很重要的因素，因该严格控制在07~0.8左右。超过0.8，CPU缓存命中率降低。所以，在闭散列中，一般负载因子超过0.7就会进行扩容处理。

为什么在散列表中不在负载因子等于1时扩容？

        因为当哈希表快满了的时候，插入数据，冲突的概率很大，然后需要查找插入位置。会导致效率降低。

扩容代码：

//扩容
//当一开始没有插入数据，哈希表大小为0
//整数/整数=整数，所以乘10，整形没小数
if (_ht.capacity() == 0 || _num * 10 / _ht.capacity() >= 7){
	int newcapacity = (_ht.capacity() == 0 ? 10 : 2 * _ht.capacity());
    //建立临时哈希对象
	HashTable<K, T, KofT> newht;
	//size就是capacity，扩容
	newht._ht.resize(newcapacity);

	for (size_t i = 0; i < _ht.size(); i++){
        //往临时对象中插入数据
		if (_ht[i]._state == EXIT){
			newht.insert(_ht[i]._data);
		}
	}
    //交换两对象数据
	_ht.swap(newht._ht);
	_num = newht._num;
    //临时对象出作用域就析构了
}

 闭散列是数据直接保存在数组中，但是，它不是很好的解决方式。当发生哈希冲突时，是去找空的位置插入数据，占用别的数据的位置。当数据很多时，冲突会越来越多。

闭散列代码实现：

namespace CLOSE_TABLE{

	enum State{
		EXIT,
		DELETE,
		EMPTY,
	};

	//kv模型,KOFT是去出key的仿函数
	template<class K, class T, class KofT>
	class HashTable
	{
	public:
		bool insert(const T& data){
			//扩容
			if (_ht.capacity() == 0 || _num * 10 / _ht.capacity() >= 7){
				int newcapacity = (_ht.capacity() == 0 ? 10 : 2 * _ht.capacity());
				HashTable<K, T, KofT> newht;
				//size就是capacity
				newht._ht.resize(newcapacity);

				for (size_t i = 0; i < _ht.size(); i++){

					if (_ht[i]._state == EXIT){
						newht.insert(_ht[i]._data);
					}
				}
				_ht.swap(newht._ht);
				_num = newht._num;
			}
			KofT koft;
			int i = 1;
			int start = koft(data) % _ht.capacity();
			size_t index = start;
			while (_ht[index]._state != EMPTY){
				if (koft(_ht[index]._data) == koft(data)){
					return false;
				}
				//index++;//线性探测
				index = (start + i*i) % _ht.capacity();//二次探测
				i++;
				if (index >= _ht.capacity()){
					index = 0;
				}
			}
			_ht[index]._data = data;
			_ht[index]._state = EXIT;
			_num++;
			return true;
		}

		int find(const T& data){
			KofT koft;
			int index = koft(data) % _ht.capacity();
			if (koft(_ht[index]._data) != koft(data)){
				while (_ht[index]._state != EMPTY){
					index++;
					if (koft(_ht[index]._data) == koft(data)){

						return index;
					}
				}


			}
			return index;
		}

		bool erase(const T& data){
			KofT koft;
			int index = find(data);
			if (koft(_ht[index]._data) == koft(data)){
				_ht[index]._state = DELETE;
				_num--;
				return true;
			}
			return false;


		}

	public:
		struct Ele{
			T _data;
			State _state = EMPTY;
		};
	private:
		vector<Ele> _ht;//数组里保存的是数据和状态
		size_t _num = 0;//元素个数
	};
}

               1.4.2 开散列

        开散列又叫链地址法(开链法)，哈希表中的数组是一个指针数组。数据是以链表的形式保存，数组的元素指向链表的头节点。

        首先，数据通过哈希函数计算出保存位置，计算出来相同位置的数据归于同一个集合中，每一个子集和称为一个桶，每一个桶中的元素通过链表连接起来，链表的头结点保存在哈希表中。

        将哈希冲突的数据一链表的方式保存在一个位置。不会占用其它数据的位置。

         开散列插入数据时，可以使用头插，尾插或者在中间插入，这个没有要求。但是采用头插法比较简单，不许要找插入位置，数组元素指向的就是链表开头。

开散列增容：

        开散列增容看的也是负载因子。

        桶的数量是一定的，因为数组的数量一定。随着元素的不断插入，桶中元素的数量会不断增多，极端情况下，可能会导致一个桶中数量链表结点非常多，在查找元素时，会影响哈希表的效率。

        因此在一定情况下要对哈希表进行增容。该条件怎么确认呢？最好的情况下，是每一个桶正好一个结点，在插入数据会发生哈希冲突，。

        因当插入元素个数正好等于桶的个数时，即负载因子等于1时，可以给哈希表增容。

        增容时，会按照哈希函数重新改变位置，减少冲突。

//检查扩容
if (_num == _ht.capacity()){

	//新容量
	int newcapacity = _ht.capacity() == 0 ? 10 : _ht.capacity() * 2;
	//建立新指针数组，来保存链表头节点
	vector<Node *> newht;
	newht.resize(newcapacity);
	//将旧数组里的链表结点，放到新数组中
	for (size_t i = 0; i < _ht.capacity(); i++){
		Node *cur = _ht[i];
		while (cur){
			//重新确定保存位置，可以减少冲突
			int index = koft(cur->_data) % newcapacity;
			//不用新创立结点，直接将旧结点重新链到新数组中
			Node *next = cur->_next;
			cur->_next = newht[index];
			newht[index] = cur;

			cur = next;

		}
		_ht[i] = nullptr;//防止野指针
	}
	//不需要交换_num，_num没变，HashTable没变，变的是里面的数组
	_ht.swap(newht);

}

 开散列代码实现：

namespace OPEN_TABLE{
	template<class T>
	struct HashNode{
		HashNode(const T& data)
		:_next(nullptr)
		, _data(data)
		{}
		T _data;
		HashNode *_next;
	};


	template<class K,class T,class KOFT>
	class HashTable{
		typedef HashNode<T> Node;

	public:
		bool insert(const T& data)
		{
			KOFT koft;
			//检查扩容
			if (_num == _ht.capacity()){

				//新容量
				int newcapacity = _ht.capacity() == 0 ? 10 : _ht.capacity() * 2;
				//建立新指针数组，来保存链表头节点
				vector<Node *> newht;
				newht.resize(newcapacity);
				//将旧数组里的链表结点，放到新数组中
				for (size_t i = 0; i < _ht.capacity(); i++){
					Node *cur = _ht[i];
					while (cur){
						//重新确定保存位置，可以减少冲突
						int index = koft(cur->_data) % newcapacity;
						//不用新创立结点，直接将旧结点重新链到新数组中
						Node *next = cur->_next;
						cur->_next = newht[index];
						newht[index] = cur;

						cur = next;

					}
					_ht[i] = nullptr;//防止野指针
				}
				//不需要交换_num，_num没变，HashTable没变，变的是里面的数组
				_ht.swap(newht);

			}
			//插入位置
			int index = koft(data) % _ht.capacity();

			//检查是否存在。
			Node *cur = _ht[index];
			while (cur){
				if (koft(cur->_data) == koft(data)){
					return false;
				}
				cur = cur->_next;
			}

			//插入结点
			Node *newnode = new Node(data);
			newnode->_next = _ht[index];
			_ht[index] = newnode;
			_num++;

			return true;
			
		}

		Node *find(const T& data){

			KOFT koft;
			int index = koft(data) % _ht.capacity();

			Node *cur = _ht[index];
			while (cur){
				if (koft(cur->_data) == koft(data)){
					return cur;
				}


				cur = cur->_next;
			}

			return nullptr;
		}

		bool erase(const T& data){
			KOFT koft;
			
			//求位置
			int index = koft(data) % _ht.capacity();

			Node *prev = nullptr;//保存cur的前一个结点，方便删除
			Node *cur = _ht[index];
			//找结点
			while (cur&&koft(cur->_data) != koft(data)){
				prev = cur;
				cur = cur->_next;
			}
			//删除结点
			if (cur){
				if (prev){//不是头节点
					prev->_next = cur->_next;
				}
				else{//是头节点
					_ht[index] = cur->_next;
				}
				delete cur;
			}
	
			
			return false;
			
		}
	private:
		vector<Node *> _ht;
		size_t _num = 0;
	};

}

        1.4.3 问题       

• 哈希函数使用时，只能直接存储Key为整形的元素。例如：除留余数法，取余时，只能时是整数取余，如果传一个string类时，取余就不能计算了。

        此时需要将被模的Key转成整形。由于现实中字符串出现的比较多，这里给除字符串转整形的思路。

        思路就是：将字符串字符中的每一个的ASCII码加起来。但是研究表明，每次相加前乘一个31，131，1313 ，13131，131313会减少冲突。

代码如下：

struct STR2INT{
	int operator()(const string& k){
		int hash = 0;
		for (int i = 0; i < k.size(); i++){
			hash *= 131;
			hash += k[i];
		}
		return hash;
	}
};

哈希表种，模板参数还需要增加一个，来将其它类型转成整形。

由于unordered_set和unordered_map底层有哈希表实现，可以看到其实unordered_set和unordered_map传模板参数种有这一个。

那为什么我们使用 unordered_set和unordered_map时key是string也可以直接使用，并不需要我们写一个仿函数传给哈希表？

 这是因为现实中字符串使用太多了，stl在哈希表中将模板进行特化了。

•  开散列如果一个桶链就是很长，数据很多，冲突很厉害，请问怎么解决？

可以设定一个值，如果桶链数超过这个值，就将链表转化为红黑树。查找效率高。