数据结构----哈希

Posted 4nc414g0n

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了数据结构----哈希相关的知识，希望对你有一定的参考价值。

哈希

概念 (略 参考了其他博客)

哈希：

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

插入元素：根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
搜索元素：对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小

当向其中插入11时会产生哈希冲突：

哈希冲突

对于两个数据元素的关键字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. 数学分析法--(了解)
    设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址

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

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

解决哈希冲突

闭散列 (线性和二次 模拟实现)

闭散列：

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

线性探测：

  • 从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止
  • 插入：
    通过哈希函数获取待插入元素在哈希表中的位置，如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素
  • 删除：
    采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素1，如果直接删除掉，11查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素

闭散列线性探测模拟实现：

  • 结构：
enum Status//标识状态

	EMPTY,
	EXITS,
	DELETE
;

//注意这里K V都是一个值，这样做是为方便unordered_map封装和方便编写，参考MAP SET实现的时候的Ketofmap和Ketofset
template<class K, class V>
struct HashData//哈希数据（包含一个_status记录状态），

	pair<K, V> _kv;
	Status _status = EMPTY;
;

template<class K>
struct HashFunc//hashfunc获取下标
;
//hashfunc的string特化
template<>
struct HashFunc<string>
;

template<class K, class V, class Hash = HashFunc<K>>
class HashTable

public:
	bool Erase(const K& key)//删
	HashData<K, V>* Find(const K& key)//查
	bool Insert(const pair<K, V>& kv)//插入
private:
	vector<HashData<K, V>> _tables;//用于hashdata存储
	size_t _n = 0; // 存储有效数据的个数
;

插入：
关于扩容：

  • 散列表的载荷因子定义为: α =填入表中的元素个数/散列表的长度，
    α是散列表装满程度的标志因子由于表长是定值，α与“填入表中的元素个数”成正比，所以，α越大，表明填入表中的元素越多，产生冲突的可能性就越大:反之，α越小，标明填入表中的元素越少，产生冲突的可能性就越小。实际上，散列表的平均查找长度是载荷因子a的函数，只是不同处理冲突的方法有不同的函数。
    对于开放定址法，荷载因子是特别重要因素，应严格限制在0.7-0.8以下。超过0.8，查表时的CPU缓存不命中( cache missing)按照指数曲线上升。因此，一些采用开放定 址法的hash库，如Java的 系统库限制了荷载因子为0.75,超过此值将resize散列表。
  • 注意：不允许重复元素，其他见注释
bool Insert(const pair<K, V>& kv)

	//不允许重复元素
	HashData<K, V>* ret = Find(kv.first);
	if (ret)
		return false;

	//当table大小为0 或存储有效数据的个数和table大小比值(载荷因子)大于等于0.7(0.8也可)扩容
	if (_tables.size() == 0 || (_n / _tables.size()) >= 0.7)
	
		size_t newsize = (_tables.size() == 0) ? 10 : _tables.size() * 2;
		HashTable<K,V> NewHashtable;
		NewHashtable._tables.resize(newsize);
		for (auto& e : _tables)
		
			if (e._status == EXIST)//由于初始化的时候HashData里的Status _status = EMPTY;有数据的为EXIST
			
				NewHashtable.Insert(e._kv);
			
		
		swap(_tables, NewHashtable._tables);//类似与拷贝构造的现代写法，局部Newtable出作用域被销毁
	
	Hash hash;
	size_t start = hash(kv.first) % _tables.size();//hash(key) = key % capacity
	size_t i = 0;//用于线性探测
	size_t index = i + start;
	while (_tables[index]._status == EXIST)
	
		i++;//如果存在，每次向后1
		index = start + i;//线性
		//index = start+i*i;//二次
		index %= _tables.size();//hash(key) = key % capacity
	
	_tables[index]._kv = kv;//存入kv
	_tables[index]._status = EXIST;//标志存在
	_n++;
	return true;

查找：

  • 注意：见注释
    当为_tables大小为0查找出错，加一层判断
    因为伪删除，需同时判断状态
HashData<K, V>* Find(const K& key)

	//当为_tables大小为0查找出错，加一层判断
	if (_n == 0)
		return nullptr;
	Hash hash;
	size_t start = hash(key) % _tables.size();
	size_t i = 0;
	size_t index = start + i;
	while (_tables[index]._status != EMPTY)
	//从HashFunc得出的键向后查找，如果是避免哈希冲突，其后必无EMPTY，遇EMPTY即无此key
	
		if (_tables[index]._status == EXIST && _tables[index]._kv.first == key)
		//注意：由于是伪删除，需同时判断状态
			return &_tables[index];
		else
		
			i++;//如果存在，每次向后1
			index = start + i;//线性
			//index = start+i*i;//二次
			index %= _tables.size();
		
	
	return nullptr;

删除：

  • 注意：见注释
    直接复用Find
    使用伪删除
bool Erase(const K& key)

	HashData<K, V>* ret = Find(key);
	if (ret)
	
		ret->_status = DELETE;//伪删除
		_n--;
		return true;
	
	else //nullptr
		return false;

关于HashFunc的string特化：

  • 参考了：字符哈希函数
    使用的BKDR Hash Function（累乘因子为31（也可以乘以31、131、1313、13131、131313.. ））
template<class K>
struct HashFunc

	size_t operator()(const K& key)
	
		return key;
	
;
template<>
struct HashFunc<string>

	size_t operator()(const string& key)
	
		//BKDR Hash
		size_t hash = 0;
		for (auto e : key)
		
			hash *= 131;
			hash += e;
		
		return hash;
	
;

二次探测：

  • 代码已经在上面注释中展示，逻辑为
//index = start + i;//线性
index = start+i*i;//二次

注意：

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

线性与二次的对比：

  • 二次：
  • 线性：

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

除此之外：基于开放寻址的其他冲突解决技术还有 合并散列，杜鹃散列，跳房子哈希，罗宾汉哈希

开散列(模拟实现)

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

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

开散列中每个桶中放的都是发生哈希冲突的元素：hash(key)=key%capacity

结构：

//每个哈希桶里面的节点
template<class K, class V>
struct HashNode

	pair<K, V> _kv;
	HashNode<K, V>* _next;
;
template<class K, class V, class Hash = HashFunc<K>>
class HashTable

	typedef HashNode<K, V> Node;
public:
	~HashTable()//由于开辟节点，需要手动释放节点，vector会自动释放
	bool Erase(const K& key)
	Node* Find(const K& key)
	bool Insert(const pair<K, V>& kv)
private:
	vector<Node*> _tables;
	size_t _n;//存储的有效数据
;

对于Insert：

  • 开散列的增容：
    桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希表进行增容，那该条件怎么确认呢？开散列最好的情况是：每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容哈希桶
  • 控制负载因子负载因子为1时 进行扩容（库里面的unordered_map::load_factor可以查看负载因子unordered_map::max_load_factor查看最大负载因子）
  • 对于K为string的情况，同闭散列
  • 注意：使用现代写法进行_tables交换：原来的_tables处e仍指向原来指针，应置空
  • 除留余数法，最好模一个素数(每次扩容时选一个最近的素数)，如何每次快速取一个类似两倍关系的素数：在ST sgi版本中有素数表(用于增容) ul: unsigned long
const int PRIMECOUNT = 28;
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];

Insert:

bool Insert(const pair<K, V>& kv)

	//哈希桶控制负载因子负载因子为1时 进行扩容
	//库里面的unordered_map::load_factor可以查看负载因子，unordered_map::max_load_factor查看最大负载因子
	if (_n == _tables.size())
	
		//size_t newsize = (_tables.size() == 0) ? 10 : _tables.size() * 2;
		//unordered_map::bucket_count查看桶的数量
		size_t newsize = GetNextPrime(_tables.size());//使用除留余数法，最好模一个素数(没有明确规定，vs版本下就没有)
		vector<Node*> newtables(newsize,nullptr);
		for (auto& e : _tables)
		
			Node* cur = e;
			while (cur)
			
				Node* next = cur->_next;//下面要更改cur->_next这里记录一下
				Hash hash;
				size_t index = hash(cur->_kv.first) % newtables.size();
				//头插
				cur->_next = newtables[index];
				newtables[index] = cur;
				cur = next;
			
			e = nullptr;//注意，原来的_tables处e仍指向原来指针，应置空
		
		newtables.swap(_tables);//现代写法
	
	//插入逻辑
	Hash hash;
	size_t index = hash(kv.first) % _tables.size();
	Node* cur = _tables[index];
	while (cur)
	
		if (cur->_kv.first == kv.first)
			return false;
		else
			cur = cur->_next;
	
	//采用头插更方便(尾插也可以)
	Node* newnode = new Node(kv);
	newnode->_next = _tables[index];
	_tables[index] = newnode;
	_n++;
	return true;

对于Erase：

  • 注意这里不是双向链表不能借用Find()
  • 需要一个prev记录cur上一个位置，防止删除要删的时cur
bool Erase(const K& key)

	if (_tables.size() == 0)
		return false;
	//注意这里不是双向链表不能借用Find()
	Hash hash;
	size_t index = hash(key) % _tables.size();
	Node* prev = nullptr;//需要一个prev记录cur上一个位置，防止删除要删的时cur
	Node* cur = _tables[index];
	while (cur)
	
		if (cur->_kv.first == key)
		
			if (prev == nullptr)
				_tables[index] = cur->_next;		 
			else
				prev->_next = cur->_next;
			delete cur;//释放cur指针
			_n--;
			return true;
		
		else
		
			prev = cur;
		cur = cur->_next;
		
	
	return false;

Find：

  • 注意除零错误
Node* Find(const K& key)

	//防止除零错误
	if (_tables.size() == 0)
		return nullptr;
	Hash hash;
	size_t index = hash(key) % _tables.size();
	Node* cur = _tables[index];
	while (cur)
	
		if (cur->_kv.first == key)
			return cur;
		else
			cur = cur->_next;
	
	return nullptr;

比较

开散列与闭散列比较

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

哈希应用

位图

引入：给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数
位图在库中有实现：

位图概念：

  • 所谓位图，就是用每一位来存放某种状态，适用于海量数据，数据无重复的场景。通常是用来判断某个数据存不存在的

模拟实现

  • bitset类私有成员：vector<char> _bits，注意也可以为int型的vector，但是就不是/8而是32了
  • 构造函数：_bits.resize(N / 8+1 , 0)_bits为1字节即8bit，相当于每个char标识8个数(+1防止出现（例如N=20，20/8=2, 不能表示所有的情况）)
  • *含有公有成员函数test(x)判断此位是否为0 set(x)设置此位为1 reset(x)重设此位为0*
  • x/8计算此在第几个char,x%8计算在此char的第几位
bitset()

	_bits.resize(N / 8+1, 0);

bool test(size_t x)

	size_t i = x / 8;//在_bits中第几个char
	size_t j = x % 8;//在这个char的第几位
	return (_bits[i] & (1 << j));

void set(size_t x)

	size_t i = x / 8;//在_bits中第几个char
	size_t j = x % 8;//在这个char的第几位
	_bits[i] |= (1 << j);

void reset(size_t x)

	size_t i = x / 8;//在_bits中第几个char
	size_t j = x % 8;//在这个char的第几位
	_bits[i] &= (~(1 << j));

测试：对于初始化bitset，可以：

(c)2006-2024 SYSTEM All Rights Reserved IT常识