由浅入深的探索Hash！

其他 2020-07-27 10:42:32 阅读次数: 0

文章目录

unordered系列的关联式容器

函数使用基本与map / set 类似，通过对底层的学习之后我们会发现哈希实际上是一种空间换时间的思想。

以unordered_map为例
unordered_map在线文档说明

  1. unordered_map是存储<key, value>键值对的关联式容器，其允许通过keys快速的索引到与其对应的
    value。
  2. 在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键
    和映射值的类型可能不同。
  3. 在内部,unordered_map没有对<kye, value>按照任何特定的顺序排序, 为了能在常数范围内找到key所
    对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
  4. unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率
    较低。
  5. unordered_maps实现了直接访问操作符(operator[])，它允许使用key作为参数直接访问value。
  6. 它的迭代器至少是前向迭代器

底层结构

哈希概念

Hash指的是把任意长度的输入通过散列算法变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值。
简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
通过这种映射关系，我们可以实现接近于O（1）时间复杂度的查询与插入。

举个例子
我们要存a这个字符，于是将a的ASCII码对10取模，将a存储在一个数组中，存储的位置下标就是取模后的值。这样我们就完成了一个简单的映射。
当我们存储b这个字符的时候，处理方式和a一样。
我们就实现了O(1)的时间复杂度的存储。

当我们查询的时候，我们输入X想找寻数组中有没有X，传统方式是遍历，但是我们可以通过对X进行ASCII对10取模得到index，然后直接在数组中看index下标位置有没有数据即可。我们就实现了O(1)时间复杂度的查询。

哈希冲突

不同关键字（可理解为插入元素）通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

哈希函数

hash函数就是用来将关键字转化散列地址的，也就是说哈希函数设计的合理与否，决定计算出来的散列地址碰撞概率的高低。

设计原则

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

哈希函数设计的好只能降低冲突概率并不能避免。

哈希冲突解决方式

开散列与闭散列的方式可以解决掉哈希冲突。

闭散列

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

将key存储到下一个冲突的位置一般有两种方法

  • 线性探测：每次向后走一个位置，进行探测。
  • 线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。
  • 二次探测：每次向后走 i*i个位置，i从一开始每次++；
  • 二次探测缺点：空间利用低 一般使用%50的空间，就要增容。

在这里插入图片描述

开散列

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

在这里插入图片描述

模拟实现

哈希表

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

template<class K>
struct SetKeyOfT {
	const K& operator()(const K& key) {
		return key;
	}
};
namespace CLOSE_HASH {
	enum State {
		EMPTY,
		EXITS,
		DELETE,
	};

	template<class T>
	struct HashData {
		T _data;
		State _state;
	};

	template<class K, class T, class KeyOfT>
	class HashTable {
		typedef HashData<T> HashData;
	public:
		bool Insert(const T& d) {
			KeyOfT koft;
			if (_nums * 10 / _tables.size() >= 7) {//增容

			}
			size_t index = koft(d) % _tables.size();
			while (_tables[index]._state == EXITS) {
				if (_tables[index]._data == koft(d)) {
					return false;
				}
				++index;
				if (index == _tables.size()) {
					index = 0;
				}
			}
			_tables[index]._data = d;
			_tables[index]._state = EXITS;
			++_nums;
			return true;
		}
		HashData Find(const K& key) {
			KeyOfT koft;
			size_t index = key % _tables.size();
			while (_tables[index]._state != EMPTY) {
				if (_tables[index]._state == EXITS) {
					if (koft(_tables[index]._data) == key) {
						return _tables[index];
					}
					return nullptr;
				}
				++index;
				if (index == _tables.size()) {
					index = 0;
				}
			}
			return nullptr;
		}
		bool Erase(const K& key) {
			HashData mydata = Find(key);
			if (mydata != nullptr) {
				mydata._state = DELETE;
				--_nums;
				return true;
			}

			return false;
		}
	private:
		vector<HashData> _tables;
		size_t _nums = 0;
	};
};
namespace OPEN_HASH {
	template<class T>
	struct HashNode {
		T _data;
		HashNode<T>* _next;

		HashNode(const T& data)
			:_data(data)
			, _next(nullptr)
		{}
	};
	template<class K, class T, class KeyOfT, class Hash> 
	class HashTable;//前置声明
	
	template<class K, class T, class KeyOfT, class Hash>
	struct __HashTableIterator {
		typedef __HashTableIterator<K, T, KeyOfT, Hash> Self;
		typedef HashTable<K, T, KeyOfT, Hash> HT;
		typedef HashNode<T> Node;
		Node* _node;
		HT* _pht;

		__HashTableIterator(Node* node, HT* ht)
			:_node(node)
			,_pht(ht)
		{}

		T& operator*() {
			return _node->_data;
		}
		
		T* operator->() {
			return &_node->_data;
		}

		Self operator++() {
			if (_node->_next) {
				_node = _node->_next;
			}
			else {
				//相当于遍历 走到了下一个桶了
				KeyOfT koft;
				size_t i = _pht->HashFunc(koft(_node->_data)) % _pht->_tables.size();
				++i;
				for (; i < _pht->_tables.size(); ++i) {
					Node* cur = _pht->_tables[i];
					if (cur) {
						_node = cur;
						return *this;
					}
				}
				_node = nullptr;
			}
			return *this;
		}
		bool operator!=(const Self& s) {
			return _node != s._node;
		}
	};

	template<class K>
	struct _Hash {
		const K& operator()(const K& key) {
			return key;
		}
	};

	template<>
	struct _Hash<string>
	{
		size_t operator()(const string& key) {
			size_t hash = 0;
			for (size_t i = 0; i < key.size(); ++i) {
				hash *= 131;
				hash += key[i];
			}
			return hash;
		}
	};
	template<class K, class T, class KeyOfT, class Hash> 
	class HashTable {
		typedef HashNode<T> Node;
	public:
		friend struct __HashTableIterator<K, T, KeyOfT, Hash>;
		typedef __HashTableIterator<K, T, KeyOfT, Hash> iterator;

		iterator begin() {
			for (size_t i = 0; i < _tables.size(); ++i) {
				if (_tables[i]) {
					return iterator(_tables[i], this);
				}
			}
			return end();
		}
		iterator end() {
			return iterator(nullptr, this);
		}
		~HashTable() {
			Clear();
		}
		void Clear() {
			for (size_t i = 0; i < _tables.size(); ++i) {
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				_tables[i] = nullptr;
			}
		}
		size_t HashFunc(const K& key) {//调用hash仿函数 返回整数
			Hash hash;
			return hash(key);
		}
		pair<iterator, bool> insert(const T& data) {
			KeyOfT koft;
			if (_tables.size() == _nums) {//增容
				vector<Node*> newTables;
				size_t newSize = _tables.size() == 0 ? 10 : 2 * _tables.size();
				newTables.resize(newSize);
				for (size_t i = 0; i < _tables.size(); ++i) {
					Node* cur = _tables[i];
					while (cur) {
						Node* next = cur->_next;
						size_t index = HashFunc(koft(cur->_data)) % newSize;
						cur->_next = newTables[index];
						newTables[index] = cur;

						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newTables);
			}

			size_t index = HashFunc(koft(data)) % _tables.size();
			//还得查找在不在表中
			Node* cur = _tables[index];
			while (cur) {
				if (koft(cur->_data) == koft(data)) {
					return make_pair(iterator(cur, this), false);//有点问题
				}
				else {
					cur = cur->_next;
				}
			}
			Node* NewNode = new Node(data);
			NewNode->_next = _tables[index];
			_tables[index] = NewNode;
			++_nums;
			return make_pair(iterator(NewNode, this), true);//有点问题
		}
		Node* Find(const K& key) {
			KeyOfT koft;
			size_t index = HashFunc(key) % _tables.size();
			Node* cur = _tables[index];
			while (cur) {
				if (koft(cur->_data) == key) {
					return cur;
				}
				cur = cur->_next;
			}
			return nullptr;
		}
		bool Erase(const K& key) {
			KeyOfT koft;
			size_t index = HashFunc(key) % _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[index];
			while (cur) {
				if (koft(cur->_data) == key) {
					if (prev == nullptr) {
						_tables[index] = cur->_next;
					}
					else {
						prev->_next = cur->_next;
					}
					delete cur;
					--_nums;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}
	private:
		vector<Node*> _tables;
		size_t _nums = 0;
	};
};

unordered_map

#pragma once
#include "HashTable.hpp"
#include <iostream>
#include <string>
using namespace OPEN_HASH;
using namespace std;

namespace mytest1 {
	template<class K, class V, class Hash=OPEN_HASH::_Hash<K>>
	class unordered_map {
		struct MapKOfT
		{
			const K& operator()(const pair<K, V>& kv) {
				return kv.first;
			}
		};
	public:
		typedef typename HashTable<K, pair<K, V>, MapKOfT, Hash>::iterator iterator;
		iterator begin() {
			return _ht.begin();
		}
		iterator end() {
			return _ht.end();
		}

		pair<iterator, bool> insert(const pair<K, V>& kv) {
			return _ht.insert(kv);
		}
		V& operator[](const K& key) {
			pair<iterator, bool> ret = _ht.insert(make_pair(key, V()));
			return ret.first->second;
		}
	private:
		HashTable<K, pair<K, V>, MapKOfT, Hash> _ht;
	};
	void test() {
		unordered_map<string, string> dic;
		dic.insert(make_pair("aaaa", "AAAA"));
		dic.insert(make_pair("bbbb", "BBBB"));
		dic.insert(make_pair("cccc", "CCCC"));
		dic.insert(make_pair("dddd", "DDDD"));
		auto it = dic.begin();
		while (it != dic.end()) {
			cout <<it->first << endl;
			++it;
		}
	}
}

unordered_set

#pragma once
#include "HashTable.hpp"
using namespace OPEN_HASH;
using namespace std;

namespace mytest2 {
	template <class K, class Hash = OPEN_HASH::_Hash<K>>
	class unordered_set {
		struct SetKofT 
		{
			const K& operator()(const K& k) {
				return k;
			}
		};
	public:
		typedef typename HashTable<K, K, SetKeyOfT, Hash>::iterator iterator;
		iterator begin() {
			return _ht.begin();
		}
		iterator end() {
			return _ht.end();
		}
		pair<iterator, bool> insert(const K& k) {
			return _ht.insert(k);
		}
	private:
		HashTable<K, K, SetKeyOfT, Hash> _ht;
	};
};

哈希的应用

位图

概念

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

应用

  1. 快速查找某个数据是否在一个集合中
  2. 排序
  3. 求两个集合的交集、并集等
  4. 操作系统中磁盘块标记

布隆过滤器

概念

布隆过滤器是由布隆（Burton Howard Bloom）在1970年提出的 一种紧凑型的、比较巧妙的概率型数据结构，特点是高效地插入和查询，可以用来告诉你 “某样东西一定不存在或者可能存在”，它是用多个哈希函数，将一个数据映射到位图结构中。此种方式不仅可以提升查询效率，也可以节省大量的内存空间。

本质上是一种结合了位图与哈希表的操作。

布隆过滤器的思想是将一个元素用多个哈希函数映射到一个位图中，因此被映射到的位置的比特位一定为1。
所以可以按照以下方式进行查找：分别计算每个哈希值对应的比特位置存储的是否为零，只要有一个为零，代表该元素一定不在哈希表中，否则可能在哈希表中。

在这里插入图片描述
注意：布隆过滤器如果说某个元素不存在时，该元素一定不存在，如果该元素存在时，该元素可能存在，因为有些哈希函数存在一定的误判。
比如：在布隆过滤器中查找"alibaba"时，假设3个哈希函数计算的哈希值为：1、3、7，刚好和其他元素的比
特位重叠，此时布隆过滤器告诉该元素存在，但实该元素是不存在的。

优点与缺陷

优点

  1. 增加和查询元素的时间复杂度为:O(K), (K为哈希函数的个数，一般比较小)，与数据量大小无关
  2. 哈希函数相互之间没有关系，方便硬件并行运算
  3. 布隆过滤器不需要存储元素本身，在某些对保密要求比较严格的场合有很大优势
  4. 在能够承受一定的误判时，布隆过滤器比其他数据结构有这很大的空间优势
  5. 数据量很大时，布隆过滤器可以表示全集，其他数据结构不能
  6. 使用同一组散列函数的布隆过滤器可以进行交、并、差运算
    缺点：
  7. 有误判率，即存在假阳性(False Position)，即不能准确判断元素是否在集合中(补救方法：再建立一个白
    名单，存储可能会误判的数据)
  8. 不能获取元素本身
  9. 一般情况下不能从布隆过滤器中删除元素
  10. 如果采用计数方式删除，可能会存在计数回绕问题

哈希切割

哈希切割是一种哈希的切分思想，通过某种特定的约定，将原来的数据分成不均匀的几部分 。方便之后的操作。
例子：
问题
比如有A B 两个数据 每个数据里面有10亿个int，我们需要查找里面的交集。内存只有1G。
分析
直接比较，内存不够，无法完成。因此需要切分。
切分方法

  1. 将A，B数据各分成1000份，进行1000*1000 次比较。
  2. 对A和B分别建立1000个map进行存储，map的下标 0-999, 将A，B中的数据对1000取模，根据取模后的数据存储对应下标即可。进行1000次比较即可。

因此通过我们不均匀的hash切割，我们就可以将相同元素放在相同下标的map中。
这就是hash切割的思想。

猜你喜欢

转载自blog.csdn.net/ifwecande/article/details/107247953
今日推荐
Linus “吃狗粮”最积极！
开源日报 | Winamp播放器即将开源；生成式AI之战升级第二轮；Linus“吃狗粮”最积极；AI进入泡沫前期；吴泳铭为阿里云带来了什么？
NetBSD 禁止提交由 AI 生成的代码
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
周排行
SVN服务端安装在阿里云
实战 | 相机标定
webpack核心概念
note20——》只要肯低头吃苦，人生就会有救
PAT甲级 1062 Talent and Virtue （25 分）排序
NG Toolset开发笔记--5GNR Resource Grid（26）
如何对待上司
oracle命令
第9章 STL迭代器
logstash使用es映射模板
每日归档
更多
2024-05-20(36)
2024-05-19(0)
2024-05-18(4)
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022