标签搜索

目 录CONTENT

文章目录

哈希原理.md

小小城
2021-08-22 / 0 评论 / 0 点赞 / 11 阅读 / 7,329 字 / 正在检测是否收录...
温馨提示:
本文最后更新于 2022-05-02,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

哈希原理

C++11提供的unordered系列的容器之所以在查找方面能够达到$O(1)$的复杂度,是因为其底层使用了哈希的结构

一、哈希的概念

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

理想的搜索方法:可以不经过任何比较,一次直接从表中得到要搜索的元素。 如果构造一种存储结构,通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系,那么在查找时通过该函数可以很快找到该元素

当向该结构中:

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

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

该方式即为哈希(散列)方法哈希方法中使用的转换函数称为哈希(散列)函数,构造出来的结构称为哈希表(Hash Table)(或者称散列表)

在这里插入图片描述

用该方法进行搜索不必进行多次关键码的比较,因此搜索的速度比较快

问题:按照上述哈希方式,向集合中插入元素44,会出现什么问题?

二、哈希冲突

对于两个数据元素的关键字ki 和kj (i != j),有 ki != kj ,但有:Hash( ki) == Hash(kj),即:不同关键字通过 相同哈希哈数计算出相同的哈希地址,该种现象称为哈希冲突或哈希碰撞

把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。 发生哈希冲突该如何处理呢?

三、哈希函数

引起哈希冲突的一个原因可能是:哈希函数设计不够合理。 哈希函数设计原则:

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

常见哈希函数

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

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

  3. 平方取中法
    假设关键字为1234,对它平方就是1522756,抽取中间的3位227作为哈希地址; 再比如关键字为4321,对它平方就是18671041,抽取中间的3位671(或710)作为哈希地址 平方取中法比较适合:不知道关键字的分布,而位数又不是很大的情况

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

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

  6. 数学分析法

四、解决哈希冲突的方法

1. 闭散列

闭散列:也叫开放定址法,当发生哈希冲突时,如果哈希表未被装满,说明在哈希表中必然还有空位置,那 么可以把key存放到冲突位置中的“下一个” 空位置中去

那如何寻找下一个空位置呢?

  1. 线性探测
    比如前面的场景,现在需要插入元素44,先通过哈希函数计算哈希地址,hashAddr为4,因此44理论 上应该插在该位置,但是该位置已经放了值为4的元素,即发生哈希冲突
    线性探测:从发生冲突的位置开始,依次向后探测,直到寻找到下一个空位置为止
  •  插入
    a.通过哈希函数获取待插入元素在哈希表中的位置
    b.如果该位置中没有元素则直接插入新元素,如果该位置中有元素发生哈希冲突,使用线性探 测找到下一个空位置,插入新元素
    c.d.e.
  •  删除
    采用闭散列处理哈希冲突时,不能随便物理删除哈希表中已有的元素若直接删除元素会影响其他 元素的搜索。比如删除元素4,如果直接删除掉,44查找起来可能会受影响因此线性探测采用标 记的伪删除法来删除一个元素
// 哈希表每个空间给个标记
// EMPTY此位置空, EXIST此位置已经有元素, DELETE元素已经删除
enum State{EMPTY, EXIST, DELETE}

线性探测的实现

// 注意:假如实现的哈希表中元素唯一,即key相同的元素不再进行插入
// 为了实现简单,此哈希表中我们将比较直接与元素绑定在一起
template<class K, class V>
class HashTable
{
	struct Elem
	{
		pair<K, V> _val;
		State _state;
	};
	
public:
	HashTable(size_t capacity = 3)
	: _ht(capacity)
	, _size(0)
	{
		for(size_t i = 0; i < capacity; ++i)
		_ht[i]._state = EMPTY;
	}
	
	bool Insert(const pair<K, V>& val)
	{
		// 检测哈希表底层空间是否充足
		// _CheckCapacity();
		size_t hashAddr = HashFunc(key);
		// size_t startAddr = hashAddr;
		while(_ht[hashAddr]._state != EMPTY)
		{
			if(_ht[hashAddr]._state == EXIST &&
 				    _ht[hashAddr]._val.first == key)
				return false;
			hashAddr++;
			if(hashAddr == _ht.capacity())
				hashAddr = 0;
		/*
		// 转一圈也没有找到,注意:动态哈希表,该种情况可以不用考		虑,哈希表中元素个数
		到达一定的数量,哈希冲突概率会增大,需要扩容来降低哈希冲突,	因此哈希表中元素是不会存满的
		if(hashAddr == startAddr)
				return false;
		*/
		}
		// 插入元素
		_ht[hashAddr]._state = EXIST;
		_ht[hashAddr]._val = val;
		_size++;
		return true;
	}
	
	int Find(const K& key)
	{
		size_t hashAddr = HashFunc(key);
		while(_ht[hashAddr]._state != EMPTY)
		{
			if(_ht[hashAddr]._state == EXIST && 					
				_ht[hashAddr]._val.first == key)
				return hashAddr;
				
			hashAddr++;
		}
		return hashAddr;
	}
	
	bool Erase(const K& key)
	{
		int index = Find(key);
		if(-1 != index)
		{
			_ht[index]._state = DELETE;
			_size++;
			return true;
		}
		return false;
	}
	
	size_t Size()const;
	
	bool Empty() const;
	
	void Swap(HashTable<K, V, HF>& ht);
	
private:
	size_t HashFunc(const K& key)
	{
		return key % _ht.capacity();
	}
	
private:
	vector<Elem> _ht;
	size_t _size;
};

思考:哈希表什么情况下进行扩容?如何扩容

在这里插入图片描述

void CheckCapacity()
{
	if(_size * 10 / _ht.capacity() >= 7)
	{
		HashTable<K, V, HF> newHt(GetNextPrime(ht.capacity));
		for(size_t i = 0; i < _ht.capacity(); ++i)
		{
			if(_ht[i]._state == EXIST)
				newHt.Insert(_ht[i]._val);
		}
		Swap(newHt);
	}
}

线性探测优点:实现非常简单,

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

2.二次探测

线性探测的缺陷是产生冲突的数据堆积在一块这与其找下一个空位置有关系,因为找空位置的方式就 是挨着往后逐个去找,因此二次探测为了避免该问题,找下一个空位置的方法为:Hi = (H0 + i^2)%m, 或者: Hi = (H0 + i^2)% mH(i + 1) = (H0 + (i + 1)^2)% m,所以H(i + 1) = Hi + 2i + 1。其中:i = 1,2,3…, 是通过散列函数Hash(x)对元素的关键码 key 进行 计算得到的位置,m是表的大小。

对于前面如果要插入44,产生冲突,使用解决后的情况为:

在这里插入图片描述

研究表明:当表的长度为质数且表装载因子a不超过0.5时,新的表项一定能够插入,而且任何一个位置 都不会被探查两次因此只要表中有一半的空位置,就不会存在表满的问题在搜索时可以不考虑表装 满的情况,但在插入时必须确保表的装载因子a不超过0.5,如果超出必须考虑增容

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

2. 开散列

  1. 开散列概念
    开散列法又叫链地址法(开链法),首先对关键码集合用散列函数计算散列地址,具有相同地址的关键码 归于同一子集合,每一个子集合称为一个桶,各个桶中的元素通过一个单链表链接起来,各链表的头结 点存储在哈希表中

在这里插入图片描述
从上图可以看出,开散列中每个桶中放的都是发生哈希冲突的元素

  1. 开散列实现
template<class V>
struct HashBucketNode
{
	HashBucketNode(const V& data)
	: _pNext(nullptr), _data(data)
	{}
	HashBucketNode<V>* _pNext;
	V _data;
};
// 本文所实现的哈希桶中key是唯一的

template<class V>
class HashBucket
{
	typedef HashBucketNode<V> Node;
	typedef Node* PNode;
public:
	HashBucket(size_t capacity = 3)
	: _size(0)
	{ 
		_ht.resize(GetNextPrime(capacity), nullptr);
	}
	// 哈希桶中的元素不能重复	
	PNode* Insert(const V& data)
	{
		// 确认是否需要扩容。。。
		// _CheckCapacity();
		// 1. 计算元素所在的桶号
		size_t bucketNo = HashFunc(data);
		// 2. 检测该元素是否在桶中
		PNode pCur = _ht[bucketNo];
		while(pCur)
		{
			if(pCur->_data == data)
				return pCur;
			pCur = pCur->_pNext;
		}
		// 3. 插入新元素
		pCur = new Node(data);
		pCur->_pNext = _ht[bucketNo];
		_ht[bucketNo] = pCur;
		_size++;	
		return pCur;
	}
	// 删除哈希桶中为data的元素(data不会重复),返回删除元素的下一个节点
	PNode* Erase(const V& data)
	{
		size_t bucketNo = HashFunc(data);
		PNode pCur = _ht[bucketNo];
		PNode pPrev = nullptr, pRet = nullptr;
		while(pCur)
		{
			if(pCur->_data == data)
			{
				if(pCur == _ht[bucketNo])
					_ht[bucketNo] = pCur->_pNext;
				else
					pPrev->_pNext = pCur->_pNext;
				pRet = pCur->_pNext;
				delete pCur;
				_size--;
				return pRet;
			}
		}
	return nullptr;
	}
	
	PNode* Find(const V& data);

	size_t Size()const;

	bool Empty()const;

	void Clear();

	bool BucketCount()const;

	void Swap(HashBucket<V, HF>& ht;

	~HashBucket();

private:

	size_t HashFunc(const V& data)
	{
		return data%_ht.capacity();
	}
private:
	vector<PNode*> _ht;
	size_t _size; // 哈希表中有效元素的个数
};
  1. 开散列增容
    桶的个数是一定的,随着元素的不断插入,每个桶中元素的个数不断增多,极端情况下,可能会导致一个桶中链表节点非常多,会影响的哈希表的性能,因此在一定条件下需要对哈希表进行增容,那该条件

怎么确认呢?开散列最好的情况是:每个哈希桶中刚好挂一个节点,再继续插入元素时,每一次都会发生哈希冲突,因此,在元素个数刚好等于桶的个数时,可以给哈希表增容

void _CheckCapacity()
{
	size_t bucketCount = BucketCount();
	if(_size == bucketCount)
	{
		HashBucket<V, HF> newHt(bucketCount);
		for(size_t bucketIdx = 0; bucketIdx < bucketCount; 			
							++bucketIdx)
		{
			PNode pCur = _ht[bucketIdx];
			while(pCur)
			{
				// 将该节点从原哈希表中拆出来
				_ht[bucketIdx] = pCur->_pNext;
				// 将该节点插入到新哈希表中
				size_t bucketNo = newHt.HashFunc(pCur->_data);
				pCur->_pNext = newHt._ht[bucketNo];
				newHt._ht[bucketNo] = pCur;
				pCur = _ht[bucketIdx];
			}
		}
		newHt._size = _size;
		this->Swap(newHt);
	}
}
  1. 开散列的思考

只能存储key为整形的元素,其他类型怎么解决?

// 哈希函数采用处理余数法,被模的key必须要为整形才可以处理,此处提供将key转化为整形的方法
// 整形数据不需要转化
template<class T>
class DefHashF
{
public:
	size_t operator()(const T& val)
	{
		return val;
	}
};

// key为字符串类型,需要将其转化为整形
class Str2Int
{
public:
	size_t operator()(const string& s)
	{
		const char* str = s.c_str();
		unsigned int seed = 131; // 31 131 1313 13131 131313
		unsigned int hash = 0;
		while (*str)
		{
			hash = hash * seed + (*str++);
		}
	return (hash & 0x7FFFFFFF);
	}
};

// 为了实现简单,此哈希表中我们将比较直接与元素绑定在一起
template<class V, class HF>
class HashBucket
{
	// ……
private:
	size_t HashFunc(const V& data)
	{
		return HF()(data.first)%_ht.capacity();
	}
};

除留余数法,最好模一个素数,如何每次快速取一个类似两倍关系的素数?

const int PRIMECOUNT = 28;
const size_t primeList[PRIMECOUNT] =
{
	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
};

size_t GetNextPrime(size_t prime)
{
	size_t i = 0;
	for(; i < PRIMECOUNT; ++i)
	{
		if(primeList[i] > prime)
			return primeList[i];
	}
	return primeList[PRIMECOUNT - 1];
}

开散列与闭散列比较

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

最后最后再说一下开散列和闭散列能否用vector自定义的扩容方式
答案是不可以

  • vector底层的扩容方式为:申请新空间-->拷贝元素--->释放旧空间,
  • 在闭散列和开散列中共同的问题是:在计算哈希地址的时候用到data%capacity,而vector是直接拷贝过来,在完成扩容后,capacity已经改变,再去用data%capacity就无法正确找到元素
  • 而在开散列中,vector每个元素存放的是每个哈希链的首地址,在释放旧空间的时候就已经把哈希链释放掉了,在新空间中却仍然在使用,就会发生错误

五、模拟实现哈希

github源码

0

评论区