C++哈希表模拟实现unordered_map 与unordered_set

news2025/1/11 2:17:33

哈希概念

unordered系列的关联式容器（如unordered_map unordered_set） 之所以效率比较高，是因为其底层使用了哈希结构

顺序结构以及平衡树 中，元素关键码与其存储位置之间没有对应的关系，因此在 查找一个元素
时，必须要经过关键码的多次比较
理想的搜索方法：可以 不经过任何比较 ， 一次 直接从表中得到要搜索的元素
哈希/散列：关键值与存储位置，建立一个关联关系
哈希 ( 散列 ) 方法：通过某种函数(hashFunc) 使元素的存储位置与它的关键值之间能够建立
一一映射的关系，那么在查找时 通过该函数 可以 很快找到该元素
哈希方法中：使用的转换函数称作 哈希(散列)函数 ，构造出来的结构 称 为 哈希表 (Hash Table)(or 散列表 )
向该结构中：
插入元素： 根据待插入元素的 关键码 ，以此 函数计算出 该元素的 存储位置 并按此位置进行存放
搜索元素： 根据待插入元素的 关键码 ，以此 函数计算出 该元素的 存储位置， 在结构中按此位置取元素比较，若关键码相等，则搜索成功

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

如若再插入99，则会发生哈希冲突

哈希冲突 

不同关键字 通过相同哈希函数计算出 相同的哈希地址 ，该种现象称为哈希冲突 或哈希碰撞 。

 

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

常见哈希函数 

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为随机数函数 
通常应用于关键字长度不等时采用此法
总之，哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

哈希冲突解决

两种方法：闭散列和开散列

闭散列（开放定址法）

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

寻找下一个空位置：hashi为元素使用哈希函数映射出的地址

1. 线性探测 hashi+i (i>=0)

2. 二次探测 hashi+i^2 (i>=0)

线性探测：

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

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

           如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突

           则使用线性探测找到下一个空位置，插入新元素

删除 ：采用伪删除法

采用闭散列处理哈希冲突时， 不能随便物理删除 哈希表中已有的元素，若直接删除元素
会影响其他元素的搜索 。比如删除元素 4 ，如果直接删除掉，则下标为4的空间为空，当查找44时，直接就是找到了一个空位置，查找结束，找不到，但实际上元素44是应该要被搜索成功的
响。因此 线性探测采用标记的 伪删除法 来删除一个元素 。 
    enum Status//标记存储值的状态
	{
		EMPTY,//空
		EXIST,//存在
		DELETE//删除
	};

哈希表设计代码（开放定址法/闭散列解决哈希冲突）

哈希表的扩容问题：

负载因子：存储关键字个数/空间大小，当负载因子为0.7时就扩容

开散列（链地址法/开链法/拉链法)

首先对关键码集合用散列函数 计算散列地址 ，具有 相同地址的关键码归于 同一子集合，每一个子集合称为 一个桶 ，各个桶中的元素通过一个 单链表链接 起来

开散列中每个桶中放的都是发生哈希冲突的元素

哈希表（开散列解决哈希冲突）模拟实现unordered_map 与unordered_set

HashTable.h

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

template<class K>
struct  HashFunc  // 哈希函数采用除留余数法，被模的key必须要为整形才可以处理
{
	size_t operator()(const K& key)
	{
		 return (size_t)key;
	}
};

template<>
struct HashFunc<string>//将字符串映射成一个整型 （若key为字符串）
{
	size_t operator()(const string& key)
	{
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 31;
			hash += e;
		}
		return hash;
	}
};


namespace hash_bucket//开散列/拉链法
{
	template<class T>
	struct  HashNode
	{
		T _data;
		HashNode<T>* _next;

		HashNode(const T& data)
			:_data(data)
			,_next(nullptr)
		{}
	};

	// 前置声明
	template<class K, class T, class Hash, class KeyOfT>
	class HashTable;

	template<class K, class T, class Ref,class Ptr,class Hash, class KeyOfT>
	struct __HTIterator
	{
		typedef  HashNode<T> Node;
		typedef __HTIterator<K, T, Ref, Ptr, Hash, KeyOfT> Self;
		Node* _node;
		const HashTable<K, T, Hash, KeyOfT>* _pht;//权限可以平移/缩小，不能放大
		size_t _hashi;

		__HTIterator(Node*node, HashTable<K, T, Hash, KeyOfT>* pht, size_t hashi)
			:_node(node)
			,_pht(pht)
			,_hashi(hashi)
		{}

		//有普通的this( HashTable的this)指针与const修饰的this指针，走更适配的
		__HTIterator(Node* node, const HashTable<K, T, Hash, KeyOfT>* pht, size_t hashi)
			:_node(node)
			, _pht(pht)
			, _hashi(hashi)
		{}

		Self& operator++()
		{
			if (_node->_next)//当前桶没走完,还有节点,走到下一个节点
			{
				_node = _node->_next;
			}
			else//当前桶已走完，找下一个桶的起始节点
			{
				++_hashi;
				while (_hashi < _pht->_tables.size())
				{
					if (_pht->_tables[_hashi])
					{
						_node = _pht->_tables[_hashi];
						break;
					}
					++_hashi;
				}

				if (_hashi == _pht->_tables.size())
				{
					_node = nullptr;
				}
			}
			return *this;
		}

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

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

		bool operator!=(const Self& s)
		{
			return _node != s._node;
		}
	};

	// unordered_set -> Hashtable<K, K>
	// unordered_map -> Hashtable<K, pair<K, V>>
	template<class K,class T,class Hash,class KeyOfT>
	class HashTable
	{
		typedef HashNode<T> Node;

		template<class K, class T, class Ref, class Ptr, class Hash, class KeyOfT>
		friend struct __HTIterator;

	public:

		typedef  __HTIterator<K, T, T&, T*, Hash, KeyOfT> iterator;
		typedef  __HTIterator<K, T, const T&, const T*, Hash, KeyOfT> const_iterator;

		iterator begin()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i])
				{
					return iterator(_tables[i], this, i);
				}
			}
			return end();
		}

		iterator end()
		{
			return iterator(nullptr,this,-1);
		}

		const_iterator begin()const
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				if (_tables[i])
				{
					return const_iterator(_tables[i], this, i);
				}
			}
			return end();
		}

		const_iterator end()const
		{
			return const_iterator(nullptr,this,-1);
		}

		HashTable()
		{
			_tables.resize(10);
		}

		~HashTable()
		{
			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;
			}
		}

		pair<iterator, bool> Insert(const T& data)
		{
			//检查是否已经存在
			Hash hf;//将关键字转成/映射成一个整型  （data可以为int，可以为string）
			KeyOfT kot;//取出data中的关键字，data若为Key则就是它本身，data若为pair，则取得pair的第一个元素

			iterator it = Find(kot(data));
			if (it != end())
				return make_pair(it, false);
			

			//检查是否需要扩容
			// 负载因子最大到1
			if (_n ==_tables.size())
			{
				vector<Node*> newTables;
				newTables.resize(_tables.size() * 2, nullptr);
				//遍历旧表
				for (size_t i = 0; i < _tables.size(); i++)
				{
					//挪动映射至新表
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t hashi = hf(kot(cur->_data)) % newTables.size();
						cur->_next = newTables[hashi];
						newTables[hashi] = cur;
						cur = next;
					}
					_tables[i] = nullptr;
				}
				_tables.swap(newTables);
			}


			size_t hashi = hf(kot(data)) % _tables.size();
			Node* newnode = new Node(data);
			//头插
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return make_pair(iterator(newnode,this,hashi), true);
		}

		iterator Find(const K& key)
		{
			Hash hf;
			KeyOfT kot;
			size_t hashi = hf(key) % _tables.size();
			
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return iterator(cur,this,hashi);
				}
				cur = cur->_next;
			}
			return end();
		}

		bool Erase(const K& key)
		{
			Hash hf;
			KeyOfT kot;
			size_t hashi = hf(key) % _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					if (prev == nullptr)//第一个就是要找的
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}

	private:
		vector<Node*> _tables;
		size_t _n = 0;
	};
}

MyUnorderedMap.h

#pragma once
#include"HashTable.h"

namespace djx
{
	template<class K,class V,class Hash = HashFunc<K>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)//获取关键字
			{
				return kv.first;
			}
		};
	public:
		typedef typename hash_bucket::HashTable<K, pair<const K, V>,  Hash, MapKeyOfT>::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;
		}

		const V& operator[](const K& key) const
		{
			pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));
			return  ret.first->second;
		}

		iterator find(const K& key)
		{
			return _ht.Find(key);
		}

		bool erase(const K& key)
		{
			return _ht.Erase(key);
		}
	private:
		hash_bucket::HashTable<K, pair<const K, V>,  Hash, MapKeyOfT> _ht;
	};
}

MyUnorderedSet.h

#pragma once
#include"HashTable.h"

namespace djx
{
	template<class K,class Hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		// 对类模板取内嵌类型，加typename告诉编译器这里是类型
		typedef typename hash_bucket::HashTable<K, K, Hash, SetKeyOfT>::const_iterator  iterator;
		typedef typename hash_bucket::HashTable<K, K, Hash, SetKeyOfT>::const_iterator  const_iterator;

		const_iterator begin() const
		{
			return _ht.begin();
		}

		const_iterator end() const
		{
			return _ht.end();
		}

		pair<const_iterator, bool> insert(const K& key)
		{
			auto ret = _ht.Insert(key);
			return make_pair(const_iterator(ret.first._node, ret.first._pht, ret.first._hashi), ret.second);
		}
		
		iterator find(const K& key)
		{
			auto ret = _ht.Find(key);
			return const_iterator(ret._node, ret._pht, ret._hashi);
		}

		bool erase(const K& key)
		{
			return _ht.Erase(key);
		}

	private:
		hash_bucket::HashTable<K, K, Hash, SetKeyOfT> _ht;
	};
}

测试：

void test_set()
{
	djx::unordered_set<int> us;
	us.insert(4);
	us.insert(19);
	us.insert(62);
	us.insert(3);

	djx::unordered_set<int>::iterator it = us.begin();
	while (it != us.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	auto e = us.find(19);
	cout << *e << endl;

	us.erase(19);
	for (auto e : us)
	{
		cout << e << " ";
	}
	cout << endl;
}

void test_map()
{
	djx::unordered_map<string, string> dict;
	dict.insert(make_pair("sort", ""));
	dict.insert(make_pair("string", ""));
	dict.insert(make_pair("insert", ""));
	for (auto& kv : dict)
	{
		//kv.first += 'x';不可以修改K
		kv.second += 'x';

		cout << kv.first << ":" << kv.second << endl;
	}
	cout << endl;

	string arr[] = { "苹果","葡萄","葡萄","甜瓜"};
	djx::unordered_map<string, int> count_map;
	for (auto& e : arr)
	{
		count_map[e]++;
	}

	for (auto& kv : count_map)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
	cout << endl;

	count_map.erase("苹果");
}

一些代码设计的细节：

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1412598.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C#-前后端分离连接mysql数据库封装接口

C#-前后端分离连接mysql数据库封装接口

C#是世界上最好的语言 新建项目 如下图所示选择框红的项目 然后新建 文件夹 Common 并新建类文件 名字任意 文件内容如下 因为要连接的是mysql数据库 所以需要安装 MySql.Data.MySqlClient 依赖; using MySql.Data.MySqlClient; using System.Data;namespace WebApplication1.…
阅读更多...
git用法总结

git用法总结

以gitee为例&#xff0c;GitHub也可参考本文 创建远程仓库 在自己的gitee主页 创建本地仓库 在文件夹下&#xff0c;右键→git bash here git init添加gitignore vi .gitignoregitignore里的内容根据自己实际情况设置&#xff0c;这里举个例子 # #开头的是注释 # Prer…
阅读更多...
【LeetCode】每日一题 2024_1_25 计算 K 置位下标对应元素的和（位运算/调库）

【LeetCode】每日一题 2024_1_25 计算 K 置位下标对应元素的和（位运算/调库）

文章目录 LeetCode&#xff1f;启动&#xff01;&#xff01;&#xff01;题目&#xff1a;计算 K 置位下标对应元素的和题目描述代码与解题思路 LeetCode&#xff1f;启动&#xff01;&#xff01;&#xff01; 今天状态调整正式结束&#xff0c;寒假学习正式开始。 题目&…
阅读更多...
编程笔记 html5cssjs 056 CSS不透明度

编程笔记 html5cssjs 056 CSS不透明度

编程笔记 html5&css&js 056 CSS不透明度 一、CSS 不透明度 / 透明度二、使用 RGBA 的透明度三、透明盒中的文本小结 不透明度/透明度。利用透明度可以提高页面的层次效果。 一、CSS 不透明度 / 透明度 opacity 属性指定元素的不透明度/透明度。 opacity 属性通常与 :h…
阅读更多...
Python学习07—字符串类型及操作

Python学习07—字符串类型及操作

一、字符串类型的表示 字符串是由0个或多个字符组成的有序序列。字符串可由一对单引号或一对双引号表示。由于字符串是有序序列&#xff0c;因此&#xff0c;可以对其中的字符进行索引&#xff0c;且在索引时&#xff0c;字符是从0开始编号。 字符串有两类和四种表示方式&…
阅读更多...
简述云原生基础定义及关键技术

简述云原生基础定义及关键技术

云原生是什么 云原生是面向“云”而设计的应用，因此技术部分依赖于传统云计算的 3 层概念，基础设施即服务（IaaS）、平台即服务（PaaS）和软件即服务（SaaS）。 例如，敏捷的不可变基础设施交付类似于 IaaS，用来提供计算网络存储等基础资源，这些资源是可编程且不可变的，直…
阅读更多...
关于MySQL的基本查询(多表查询等)

关于MySQL的基本查询(多表查询等)

1.创建student和score表 CREATE TABLE student ( id INT(10) NOT NULL UNIQUE PRIMARY KEY , name VARCHAR(20) NOT NULL , sex VARCHAR(4) , birth YEAR, department VARCHAR(20) , address VARCHAR(50) ); 创建score表。SQL代码如下&#xff1a; CREATE…
阅读更多...
动态规划之买卖股票问题（篇二）（买卖股票的最佳时机）

动态规划之买卖股票问题（篇二）（买卖股票的最佳时机）

本篇博客主要讲解123.买卖股票的最佳时机III和188.买卖股票的最佳时机IV&#xff0c;是上篇博客中动态规划之买卖股票问题&#xff08;篇一&#xff09;&#xff08;买卖股票的最佳时机&#xff09;股票问题的进阶。 123.买卖股票的最佳时机III 题目&#xff1a; 给定一个数…
阅读更多...
11k+ star 一款不错的笔记leanote安装教程

11k+ star 一款不错的笔记leanote安装教程

特点 支持普通模式 支持markdown模式 支持搜索 安装教程 1.安装mongodb 1.1.下载 #下载 cd /opt wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-3.0.1.tgz 1.2解压 tar -xvf mongodb-linux-x86_64-3.0.1.tgz 1.3配置mongodb环境变量 vim /etc/profile 增…
阅读更多...
【软件测试】学习笔记-构建并执行 JMeter 脚本的正确姿势

【软件测试】学习笔记-构建并执行 JMeter 脚本的正确姿势

有些团队在组建之初往往并没有配置性能测试人员&#xff0c;后来随着公司业务体量的上升&#xff0c;开始有了性能测试的需求&#xff0c;很多公司为了节约成本会在业务测试团队里选一些技术能力不错的同学进行性能测试&#xff0c;但这些同学也是摸着石头过河。他们会去网上寻…
阅读更多...
Go语言指针变量

Go语言指针变量

1. 指针变量 区别于C/C中的指针&#xff0c;Go语言中的指针不能进行偏移和运算&#xff0c;是安全指针。 Go语言中的指针3个概念&#xff1a;指针地址、指针类型和指针取值。 1.1. Go语言中的指针 Go语言中的函数传参都是值拷贝&#xff0c;当我们想要修改某个变量的时候&a…
阅读更多...
zuul网关

zuul网关

zuul网关 zuul自定义过滤器hystrix和ribbon时间RibbonAutoConfiguration自动配置FeignAutoConfiguration自动配置RibbonEurekaAutoConfigurationSendErrorFilter过滤器EnableZuulServerHasFeatures EnableZuulProxy zuul自定义过滤器 继承ZuulFilter类&#xff0c;实现其方法f…
阅读更多...
【论文笔记】Learning Deconvolution Network for Semantic Segmentation

【论文笔记】Learning Deconvolution Network for Semantic Segmentation

重要说明&#xff1a;严格来说&#xff0c;论文所指的反卷积并不是真正的 deconvolution network 。 关于 deconvolution network 的详细介绍&#xff0c;请参考另一篇博客&#xff1a;什么是Deconvolutional Network&#xff1f; 一、参考资料 Learning Deconvolution Netwo…
阅读更多...
十分钟搭建本地Linux开发运行环境

十分钟搭建本地Linux开发运行环境

十分钟搭建本地开运行环境 linux环境请参考&#xff1a;5分钟搭建本地linux开发环境 环境&#xff1a;宝塔、Jdk、Mysql、Redis 1、宝塔&#xff1a; 官网地址&#xff1a;宝塔官网 yum install -y wget && wget -O install.sh https://download.bt.cn/install/in…
阅读更多...
图形化方式利用脚手架创建Vue项目

图形化方式利用脚手架创建Vue项目

图形化方式利用脚手架创建Vue项目 1 安装node.js&#xff08;附带安装npm&#xff09;安装v14.3.0版本 查看安装版本 node -v 2 安装cnpm npm install -g cnpm 查看安装版本 cnpm -v 以管理员身份运行powershell&#xff0c;运行 set-ExecutionPolicy RemoteSigned 3…
阅读更多...
【VSAN数据恢复】VSAN数据重构迁移失败的数据恢复案例

【VSAN数据恢复】VSAN数据重构迁移失败的数据恢复案例

VSAN简介&#xff1a; VSAN存储是一个对象存储&#xff0c;以文件系统呈现给在vSphere主机上。这个对象存储服务会从VSAN集群中的每台主机上加载卷&#xff0c;将卷展现为单一的、在所有节点上都可见的分布式共享数据存储。 对于虚拟机来说&#xff0c;只有一个数据存储&#x…
阅读更多...
Modern C++ std::shared_ptr的实现原理

Modern C++ std::shared_ptr的实现原理

shared_ptr的UML图 注意：这是Linux上GCC 8.5.0的实现版本 先看下它的继承关系。 shared_ptr里面的数据成员 有了上面的UML图，可能还没有一个直观的认识，下面我们把这些成员打印出来。 当然得先写个小小的程序： $ cat shared_ptr.cpp #include <memory> #include…
阅读更多...
单元测试——题目十二

单元测试——题目十二

目录 题目要求： 定义类 测试类 题目要求： 根据下列流程图编写程序实现相应处理，执行j=10*x-y返回文字“j1=：”和计算值，执行j=(x-y)*(10⁵%7)返回文字“j2=：”和计算值，执行j=y*log(x+10)返回文字“j3=：”和计算值。 编写程序代码，使用JUnit框架编写测试类对编写的…
阅读更多...
【开源】基于JAVA语言的实验室耗材管理系统

【开源】基于JAVA语言的实验室耗材管理系统

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块2.1 耗材档案模块2.2 耗材入库模块2.3 耗材出库模块2.4 耗材申请模块2.5 耗材审核模块 三、系统展示四、核心代码4.1 查询耗材品类4.2 查询资产出库清单4.3 资产出库4.4 查询入库单4.5 资产入库 五、免责说明 一、摘要 1.1…
阅读更多...
RHCE项目：使用LNMP搭建私有云存储

RHCE项目：使用LNMP搭建私有云存储

目录 一、准备工作 1、关闭防火墙、安全软件 2、搭建LNMP环境 3、上传软件 4、设置nextcloud安装命令权限 二、数据库 1、设置数据库 2、重启数据库 三、配置nginx 四、安装nextcloud 五、内网穿透 1、创建内网映射 2、linux系统安装花生壳客户端 3、重新打开浏览…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023