[数据结构] 哈希表

最新推荐文章于 2021-11-27 05:00:00 发布

一氧化二氢的执着

最新推荐文章于 2021-11-27 05:00:00 发布

阅读量396

点赞数

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/new_bee_01/article/details/104734512

版权

数据结构专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

1. 哈希概念

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

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

当向该结构中：

插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
搜索元素
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功

常见哈希函数
1. 直接定制法
取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀缺点：需要事先知道关键字的分布情况使用场景：适合查找比较小且连续的情况面试题：字符串中第一个只出现一次字符
2. 除留余数法
设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址

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

例如：数据集合{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。
在这里插入图片描述
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快
按照上述哈希方式，向上面的集合中插入元素44，会出现什么问题？

2. 哈希冲突

对于两个数据元素的关键字有：Hash( ) == Hash( )，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。
发生哈希冲突该如何处理呢？

3. 哈希冲突解决

3.1 闭散列

闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。那如何寻找下一个空位置呢？
1. 线性探测
比如2.1中的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

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

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

上述哈希表还存在以下的缺陷：

只能存储key为整形的元素，其他类型怎么解决
哈希函数采用处理余数法，被模的key必须要为整形才可以处理，提供将key转化为整形的方法
使用仿函数!传入比较方法 字符串哈希算法

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

template<class K, class V, class HF>
class HashTable
{
// ……
private:
	size_t HashFunc(const K& key)
	{
		return HF()(key)%_ht.capacity();
	}
};

除留余数法，最好模一个素数，如何每次快速取一个类似两倍关系的素数？
提前写好表

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
};

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

2. 二次探测
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：Hi = (H0 + i2)% m,或者：Hi = (H0 - i2)% m. 其中：i = 1,2,3…，是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。对于2.1中如果要插入44，产生冲突，使用解决后的情况为:
在这里插入图片描述

研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。
因此：闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷

3.2 开散列

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

在这里插入图片描述

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

4. 哈希表的增容

vector增容, 满了就增容, 增容只需要开辟更大空间, 拷贝数据, 释放旧空间
Hash表增容, 负载因子 == (开放地址法)0.7 或 (哈希桶)1 增容, 开辟新的更大空间, 将旧表的数据重新映射到新表, 释放旧空间. 增容成本大

5. 开散列模拟实现*

#pragma once
#include <vector>
using namespace std;

template <class K>
class HashNode
{
public:
	HashNode(const K& key)
		: _key(key)
		, _pNext(nullptr)
	{ }
	K _key;
	HashNode* _pNext;
};



template <class K>
class HashBucket
{
public:
	typedef HashNode<K> Node;
	bool insert(const K& key)
	{
		// 扩容, 负载因子控制到1
		if (_ht.size() == _dataNum)
		{
			size_t newSize = _ht.size() == 0 ? 5 : _ht.size() * 2;
			vector<Node*> newHt;
			newHt.resize(newSize, nullptr);

			// 旧表的数据节点取下来，重新算在新表中的位置
			for (size_t i = 0; i < _ht.size(); i++)
			{
				Node* pCur = _ht[i];
				while (pCur)
				{
					Node* pNext = pCur->_pNext;
					size_t index = pCur->_key % newSize;
					pCur->_pNext = newHt[index];
					newHt[index] = pCur;
					pCur = pNext;
				}
				pCur = nullptr;
			}
			_ht.swap(newHt);
		}
		// 查找key是否存在，存在则不插入。（multi版本则不作冗余检查，直接进行下面的插入）
		size_t index = key % _ht.size();
		Node* pCur = _ht[index];
		while (pCur)
		{
			if (pCur->_key == key)
			{
				return false;
			}
			pCur = pCur->_pNext;
		}
		// 头插
		Node* newNode = new Node(key);
		newNode->_pNext = _ht[index];
		_ht[index] = newNode;

		++_dataNum;
		return true;
	}

	Node* find(const K& key)
	{
		size_t index = key % _ht.size();
		Node* pCur = _ht[index];
		while (pCur)
		{
			if (pCur->_key == key)
			{
				return pCur;
			}
			pCur = pCur->_pNext;
		}
		return nullptr;
	}

	bool erase(const K& key)
	{
		size_t index = key % _ht.size();
		Node* pCur = _ht[index];
		Node* pPrev = nullptr;
		while (pCur)
		{
			if (pCur->_key == key)
			{
				break;
			}
			pPrev = pCur;
			pCur = pCur->_pNext;
		}
		if (pCur == nullptr)
		{
			return false;
		}
		if (pCur != _ht[index])
		{
			pPrev->_pNext = pCur->_pNext;

		}
		else
		{
			_ht[index] = pCur->_pNext;
		}
		delete pCur;
		pCur = nullptr;
		_dataNum--;
		return true;
	}
	

private:
	vector<Node*> _ht;
	size_t _dataNum = 0;
};