当前位置:   article > 正文

【数据结构】哈希

【数据结构】哈希


在这里插入图片描述

unordered 系列的关联式容器之所以效率比较高,是因为其底层使用了哈希结构。

1. 哈希概念

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

理想的搜索方法:可以不经过任何比较,一次直接从表中得到要搜索的元素

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

当向该结构中:

  • 插入元素

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

  • 搜索元素

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

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

例如:数据集合 { 1, 7, 6, 4, 5, 9 };

哈希函数设置为:hash(key) = key % capacity; capacity 为存储元素底层空间总的大小。

在这里插入图片描述

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

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

2. 哈希冲突

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

把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”

发生哈希冲突该如何处理呢?

3. 哈希函数

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

哈希函数设计原则

  • 哈希函数的定义域必须包括需要存储的全部关键码,而如果散列表允许有 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. 随机数法(了解)

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

  6. 数学分析法(了解)

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

    在这里插入图片描述

    假设要存储某家公司员工登记表,如果用手机号作为关键字,那么极有可能前 7 位都是相同的,那么我们可以选择后面的四位作为散列地址,如果这样的抽取工作还容易出现冲突,还可以对抽取出来的数字进行反转(如 1234 改成 4321)、右环移位(如 1234 改成 4123)、左环移位、前两数与后两数叠加(如 1234 改成 12+34=46)等方法;
    数字分析法通常适合处理关键字位数比较多的情况

注意:哈希函数设计的越精妙,产生哈希冲突的可能性就越低,但是无法避免哈希冲突

4. 哈希冲突解决

解决哈希冲突两种常见的方法是:闭散列开散列

4.1 闭散列

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

  1. 线性探测

    比如上面的场景:

    在这里插入图片描述

    现在需要插入元素 44,先通过哈希函数计算哈希地址,hashAddr 为 4,因此 44 理论上应该插在该位置,但是该位置已经放了值为 4 的元素,即发生哈希冲突。

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

    • 插入

      • 通过哈希函数获取待插入元素在哈希表中的位置

      • 如果该位置中没有元素则直接插入新元素,如果该位置中有元素发生哈希冲突,使用线性探测找到下一个空位置,插入新元素

        在这里插入图片描述

    • 删除

      采用闭散列处理哈希冲突时,不能随便物理删除哈希表中已有的元素,若直接删除元素会影响其他元素的搜索。比如删除元素 4,如果直接删除掉,44 查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素

      // 哈希表每个空间给个标记
      // EMPTY此位置空, EXIST此位置已经有元素, DELETE元素已经删除
      enum State
      {
      	EMPTY,
      	EXIST,
      	DELETE
      };
      
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
  2. 线性探测的实现

    // 注意:假如实现的哈希表中元素唯一,即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;
    };
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87

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

    在这里插入图片描述

    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);
    	}
    }
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

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

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

  3. 二次探测

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

    对于上面案例,如果要插入 44,产生冲突,使用二次探测解决后的情况为:

    在这里插入图片描述

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

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

4.2 开散列

  1. 开散列的概念

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

    个人理解:哈希桶 = 顺序表 + 链表 + 哈希算法;

    在这里插入图片描述

    在这里插入图片描述

    从上图可以看出,开散列中每个桶中放的都是发生哈希冲突的元素

  2. 开散列实现

    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
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
  3. 开散列增容

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

    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
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
  4. 开散列的思考

    • 只能存储 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();
      	}
      };
      
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
    • 除留余数法,最好模一个素数,如何每次快速取一个类似两倍关系的素数?

      size_t GetNextPrime(size_t prime)
      {
      	const int PRIMECOUNT = 28;
      	static 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 i = 0;
      	for (; i < PRIMECOUNT; ++i)
      	{
      		if (primeList[i] > prime)
      			return primeList[i];
      	}
      	return primeList[i];
      }
      
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
  5. 开散列与闭散列比较

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


END
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/我家小花儿/article/detail/421176
推荐阅读
相关标签
  

闽ICP备14008679号