[C++]哈希

已于 2023-08-18 03:03:24 修改
阅读量52 收藏
点赞数
分类专栏： C++ 文章标签： 哈希算法 c++ 数据结构
于 2023-05-25 12:23:39 首次发布
附上ID和原文链接即可
本文链接：https://blog.csdn.net/sewerperson/article/details/130857107
版权

文章目录

一、哈希的基本介绍

性能上

查找数据，哈希时间复杂度为O(1)
大量随机数据插入，map和set性能快
大量随机数据删除，map和set性能快

哈希映射方法

1.直接定址法:每个值都有自己唯一的位置
优点:无哈希冲突,简单且均匀
缺点:如果空间分散会有很大的空间浪费
适应于范围小且连续的情况

2,除留余数法
优点:空间合适且不浪费过多的空间
缺点:可能存在有相同的映射地址(哈希冲突)

哈希大部分都围绕着解决哈希冲突

1.闭散列:冲突后占用下一个空位置
缺点：查找效率变低，互相冲突导致插入逻辑复杂
线性探测:线性找下一个空位置,++
二次探测:平方步调找下一个位置,^2

2.开散列(哈希桶)(拉链法):冲突的位置下加上链表(哈希桶),由此STL中并没有双向迭代器
缺点:链表太长有效率问题
优点:冲突不会相互影响

二、闭散列的哈希表实现

实际中开散列应用情况优于闭散列,点一下

#include<iostream>
#include<vector>
using namespace std;

template<class K>
struct KeyToCmp //得到可以进行比较的数据
{
	size_t operator()(const K& k)
	{
		return (size_t)k;
	}
};

template<>
struct KeyToCmp<string> //特化一个string的仿函数,使得字符也能有其映射的地址
{
	size_t operator()(const string& k)
	{
		size_t hash = 0;
		for (auto& e : k)
		{
			hash += e;
		}
		return hash;
	}
};


enum State
{
	EMPTY,
	EXIST,
	DELETE
};
	
template<class K,class V>
struct HashData
{
	pair<K,V> _kv;
	State _state = EMPTY; //通过加入状态成员来方便进行增删查改
};
	
template<class K,class V,class Hash = KeyToCmp<int>>
class HashTable
{
public:
	typedef HashData<K,V> Data;

	HashTable() //构造
	{
		_tables.resize(10);
	}


	//负载因子 = 表中数据/表的大小  衡量哈希表满的程度
	//负载因子越大,插入数据越容易发生哈希冲突,冲突越多,效率越低
	//所以哈希表并不是满了才增容,一般负载因子在0.7左右就开始增容
	//控制的太小,会使得空间浪费
	bool Insert(const pair<K,V>& kv)
	{
		if (Find(kv.first) != nullptr) //已经有了
			return false;
		
		if (_num * 10 / _tables.size() >= 7) //负载因子大了,开始增容
		{
			HashTable<K, V, Hash> tmp;
			tmp._tables.resize(2 * _tables.size()); //新创建一个哈希表,将其数组空间扩大至旧哈希表的两倍
			
			for (auto& e : _tables)
			{
				if (e._state == EXIST) //如果有数据
					tmp.Insert(e._kv); //插入,扩容已经在上面完成了,递归时判断增容条件进不去,不会造成死循环
			}
			_tables.swap(tmp._tables);
		}

		Hash get;
		size_t index = get(kv.first) % _tables.size();

		while (_tables[index]._state == EXIST)
		{
			index++;
			index %= _tables.size();
		}

		_tables[index]._kv = kv;
		_tables[index]._state = EXIST;
		_num++;
		
		return true;
	}


	Data* Find(const K& k)
	{
		
		Hash get;
		size_t index = get(k) % _tables.size();

		while (_tables[index]._state != EMPTY)
		{
			if (_tables[index]._state == EXIST && _tables[index]._kv.first == k)
				return &_tables[index];
			index++;
			index %= _tables.size();
		}
		return nullptr; //哈希冲突是连续的,如果第一个后面为空,说明后面也没有冲突的情况,直接返回
	}


	bool Erase(const pair<K, V>& kv)
	{
		Data* ret = Find(kv.first);
		if (ret)
		{
			ret->_state = DELETE;
			--_num;
			return true;
		}
		else
		{
			return false;
		}
	}
	
private:
	vector<Data> _tables;
	size_t _num = 0; //存储当前存储有效数据的个数
};

三、开散列模拟实现unordered_xxx

unordered_xxx底层都是由开散列实现的

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

namespace BsyOpen
{
	template<class K>
	struct GetWay
	{
		const K& operator()(const K& k)
		{
			return k;
		}
	};

	template<> //特化处理字符串,使得其返回值能够被模
	struct GetWay<string>
	{
		size_t operator()(const string& k)
		{
			size_t way = 0;
			for (size_t i = 0; i < k.size(); ++i)
			{
				way *= 131; //BKDR Hash,使得哈希冲突降低
				way += k[i];
			}
			return way;
		}
	};


	template<class T> //一个哈希表节点
	struct HashNode 
	{
		T _data;
		HashNode<T>* _next;
		//我们自己实现的哈希输出,并非输入的顺序,如果要实现按输入顺序输出就要多指针
		//HashNode<T>* _linknext; //以按顺序输出
		//HashNode<T>* _linkprev; //以删除

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


	// 前置声明一下, 否则在迭代器类中, 无法识别出HashTable是什么
	template<class K, class T, class TheKey, class GetWayy> //哈希表
	class HashTable; 

	template<class K,class T,class TheKey,class GetWayy> //哈希表迭代器
	struct __HashIterator
	{
		typedef __HashIterator< K, T, TheKey, GetWayy> Self;
		typedef HashTable<K, T, TheKey, GetWayy> HT;
		typedef HashNode<T> Node;
		Node* _node;
		HT* _pht; //以便在后续operator++中起到作用

		__HashIterator(Node* node,HT* pht)
			:_node(node)
			,_pht(pht)
		{}

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

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

		Self operator++()
		{
			if (_node->_next)
			{
				_node = _node->_next; //如果桶没走完接着往下走
			}
			else
			{
				TheKey thekey;
				GetWayy getway;
				//计算数值应该位于哪个头节点
				size_t i = getway(thekey(_node->_data)) % _pht->_tables.size();
			  //size_t i = GetWayy()(TheKey()(_node->_data)) % _pht->_tables.size();
				i++; //现在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,class T,class TheKey,class GetWayy> //哈希表
	class HashTable
	{
	public:
		friend struct __HashIterator< K, T, TheKey, GetWayy>;
		typedef HashNode<T> Node;
		typedef __HashIterator< K, T, TheKey,GetWayy> 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() //销毁完桶之后,,析构自动销毁this,即vector会随着析构函数销毁
		{
			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 GetNextPrime(size_t num) //这是一种算法,使得可以减小哈希冲突
		{
			const int primecount = 28;
			const size_t primelist[primecount] = //二倍关系质数表
			{
				53,97,193,389,769,
				1543,3079,6151,12289,24593,
				49157,98317,1996613,393241,786433,
				1572869,3145739,6291469,12582917,25165843,
				50331653,100663319,201326611,402653189,805306457,
				1610612741,3221225473,4294967291
			};

			for (size_t i = 0; i < primecount; ++i)
			{
				if (primelist[i] > num)
				{
					return primelist[i];
				}
			}
			return primelist[primecount - 1]; //如果还大,就一直返回最后一个
		}

		pair<iterator,bool> Insert(const T& data)
		{
			TheKey thekey;
			GetWayy getway;

			if (_num == _tables.size()) //此时负载因子为1,避免以后造成大量冲突,增容
			{
				vector<Node*> newtable;
				size_t newsize = GetNextPrime(_num);
				newtable.resize(newsize);
				for (size_t i = 0; i < _tables.size(); ++i)
				{
					Node* cur = _tables[i]; //取每个头
					while (cur)
					{
						//旧表取下重新计算新表中的位置
						Node* next = cur->_next;
						size_t index = getway(thekey(cur->_data)) % newtable.size(); //新表中的位置
						cur->_next = newtable[index]; //头插进去
						newtable[index] = cur;
						cur = next;
					}
					_tables[i] = nullptr; 
				}
				_tables.swap(newtable);
			}


			size_t index = getway(thekey(data)) % _tables.size();

			Node* cur = _tables[index];
			while (cur)
			{
				if (thekey(cur->_data) == thekey(data)) //重复了,不插入,结束
					return make_pair(iterator(cur,this),false);
				else
					cur = cur->_next;
			}

			//检验完后走到这里说明可以插入了
			//选择头插,因为有头节点的位置,不用找尾
			Node* newnode = new Node(data);
			newnode->_next = _tables[index];
			_tables[index] = newnode;

			++_num;
			return make_pair(iterator(newnode, this), true);
		}

		Node* Find(const K& k)
		{
			TheKey thekey;
			GetWayy getway;
			size_t index = getway(k) % _tables.size();
			Node* cur = _tables[index];
			while (cur)
			{
				if (thekey(cur->_data) == k)
					return cur;
				else
					cur = cur->_next;
			}
			return nullptr;
		}


		bool Erase(const K& k)
		{
			TheKey thekey;
			GetWayy getway;
			size_t index = getway(k) % _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[index]; //找到需要找到数据的头
			while (cur)
			{
				if (thekey(cur->_data) == k)//找到了
				{

					if (prev == nullptr) //说明要删除的对象就是第一个节点
						_tables[index] = cur->_next;
					else
						prev->_next = cur->_next;
					
					delete cur;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}

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

1.unordered_set

#pragma once
#include"Open_Hash.hpp"

namespace Bsy
{
	template<class K, class GetWayy = BsyOpen::GetWay<K>>
	class unordered_set
	{
		struct TheKeyOfSet
		{
			const K& operator()(const K& k)
			{
				return k;
			}
		};


	public:
		typedef typename BsyOpen::HashTable<K, K, TheKeyOfSet, GetWayy>::iterator iterator;

		iterator begin()
		{
			return _ht.begin();
		}

		iterator end()
		{
			return _ht.end();
		}

		pair<iterator,bool> insert(const K& k)
		{
			return _ht.Insert(k);
		}

	private:
		BsyOpen::HashTable<K, K, TheKeyOfSet,GetWayy> _ht;
	};

	void test_unordered_set1()
	{
		unordered_set<int> s;
		s.insert(1);
		s.insert(5);
		s.insert(6);
		s.insert(2);

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

}

2.unordered_map

#pragma once
#include"Open_Hash.hpp"

namespace Bsy
{
	template<class K,class V, class GetWayy = BsyOpen::GetWay<K>>
	class unordered_map
	{
		struct TheKeyOfMap
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};

	public:
		typedef typename BsyOpen::HashTable<K, pair<K,V>, TheKeyOfMap, GetWayy>::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& k)
		{
			//pair<iterator, bool> ret = _ht.Insert(make_pair(k, V()));
			//return ret.first->second;
			return _ht.Insert(make_pair(k, V())).first->second;
		}

	private:
		BsyOpen::HashTable<K, pair<K, V>, TheKeyOfMap,GetWayy> _ht;
	};


	void test_unordered_map1()
	{
		unordered_map<string, string> dict;
		dict.insert(make_pair("sort", "paixu"));
		dict.insert(make_pair("left", "zuo"));
		dict.insert(make_pair("long", "chang"));
		dict["left"] = "you";
		dict["hash"] = "haxi";

		unordered_map<string, string>::iterator it = dict.begin();
		while (it != dict.end())
		{
			cout << it->first <<":"<<it->second<< endl;
			++it;
		}
		cout << endl;
	}
}
nitesy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用C++哈希表实现的学生信息管理系统
04-02
数据结构课程设计之——使用C++哈希表实现的学生信息管理系统。 编译器选择DevC++ 或者 VS2019都可，按照要求新建文件，运行即可。 一、程序的主要功能 程序分为四个模块： 1.建立哈希表：有三个功能（1）插入一个...
C++哈希表实现.zip
08-20
在C++中，虽然标准库没有直接提供哈希表，但我们可以通过自定义结构来实现。本压缩包包含两个文件：`HashTest.cpp` 和 `Hashtable.h`，它们展示了如何用C++来构建一个简单的哈希表。 在`Hashtable.h`中，我们通常会...
C++哈希表与六子棋的应用学习代码
03-01
c 哈希表 六子棋（Gomoku，又称为五子棋或连珠）是一个两人对战的策略游戏。在这个游戏中，玩家轮流在棋盘上放置棋子，目标是首先形成一条连续的五个或更多同色棋子的直线（横、竖、斜均可）。 下面是一个简单的六...
哈希表de 设计.rar_c++ 哈希表_哈希_哈希 VC_哈希表
09-23
在C++中，哈希表通常通过自定义实现或使用标准库中的`unordered_map`来实现。本文将深入探讨哈希表的设计原理、工作方式以及在C++中的应用。 哈希表的核心思想是通过哈希函数将键（key）映射到数组的索引位置，以...
c++的哈希表hash
03-18
c
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 504
C语言 | Leetcode C语言题解之第389题找不同
QWidget(c++)嵌入window环境的exe
sunflower_2020的博客
09-05 284
QWidget(c++)嵌入window环境的exe
Linux和C语言（Day10）
最新发布
weixin_65095004的博客
09-10 679
实现特定功能的代码块定义函数： 存储类型 数据类型 函数名(参数列表){ 实现特定功能的代码块 }
C/C++基本语言相关面试题
gopher9511的博客
09-10 795
浅拷贝:浅拷贝在复制对象时，只复制对象中的基本数据类型成员和指针值，而不复制指针指向的内存内容。这意味着复制后的对象中的指针将与原对象共享同一块内存。如果某个对象被析构，而该对象的指针指向的内存也被释放，那么其他共享同一内存的对象可能会访问已释放的内存，导致未定义行为甚至程序崩溃。这种情况称为“双重释放”（double free）。在C++中，如果没有为类定义自定义的拷贝构造函数，编译器提供的默认拷贝构造函数就是浅拷贝。
c++ 类的继承详解
HJQD777的博客
09-07 474
继承允许类之间建立层次关系，促进代码重用和扩展。继承有不同的访问控制方式（publicprotectedprivate），影响派生类对基类成员的访问权限。基类的构造函数和析构函数不会被继承，派生类需要自行定义。使用虚函数和多态可以实现灵活的接口设计和动态方法调用。理解继承机制对于设计高效、灵活和可维护的面向对象系统至关重要。
C和指针：预处理(#include/define/if...)
暮色年华的博客
09-10 394
预处理器把所有name替换成 stuff。在程序中扩展#define定义符号和宏时，需要涉及几个步骤：1.在调用宏时，首先对参数进行检查，看看是否包含了任何由#define 定义的符号。如果是，它们首先被替换。2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替代。3.最后，再次对结果文本进行扫描，看看它是否包含了任何由#define 定义的符号。如果是，就重复上述处理过程。这样，宏参数和#define 定义可以包含其他#define定义的符号。但是，宏不可以出现递归。
【启明智显技术分享】探讨CAN总线相关知识以及Model3C 2路CAN的应用
ami82的博客
09-05 659
通信错误：由于CAN总线上的节点之间存在不同的优先级，可能导致数据冲突。总线阻塞：在某些情况下，CAN总线上的节点可能会长时间保持发送状态，从而导致其他节点无法发送数据，这种现象被称为总线阻塞。总线干扰：CAN总线可能会受到外部电磁干扰，如电源干扰、射频干扰等，这些干扰可能导致总线上的数据传输出错。总线过载：当CAN总线上的节点数量过多或者通信数据量过大时，可能导致总线过载，从而影响通信性能和稳定性。总线错误：CAN总线上的节点可能会发生硬件故障，例如控制器损坏、接口损坏等，这些情况都可能导致总线错误。
Qt/C++ 个人开源项目#串口助手（源码与发布链接）
填坑之路
09-06 612
该串口助手提供了编译好的发布包，用户可以自行下载可以直接启动应用。在应用界面中，选择要连接的串口设备，配置相关串口参数，点击“连接”即可开始数据通信。工具具有直观的用户界面和丰富的功能，旨在帮助用户与串口设备建立可靠通信，便于调试、数据传输和分析。串口助手具备自动检测功能，可以自动识别当前系统中的串口设备。：支持实时显示从串口设备接收的数据，用户可以选择显示格式（如十六进制、ASCII等）。：用户可以通过界面输入并发送数据，支持单次发送和定时发送，便于测试连续传输。：支持无校验、奇校验、偶校验等。
C 语言实例：掌握基础与进阶技巧
wjs2024的博客
09-10 149
C 语言作为一门古老而强大的编程语言，自诞生以来就广受欢迎。它以其高效率、灵活性和功能强大著称，是许多现代编程语言的基础。本文旨在通过一系列实例，帮助读者深入理解 C 语言的基础知识和进阶技巧。
【项目二】C++高性能服务器开发——日志系统(日志器，日志级别，日志事件)
weixin_45962681的博客
09-06 185
其实也没啥。
C++ 标准库的典型内容
qq_68194402的博客
09-10 655
C++ 标准库提供了一系列强大且灵活的工具和组件，用于简化程序设计和提高开发效率。它包含多种功能模块，涵盖了内存管理、数据结构、算法、输入输出操作以及类型特征等多个方面
《C++位域：在复杂数据结构中的精准驾驭与风险规避》
xy520521的博客
09-10 330
通过明确位域的用途和限制、避免跨平台依赖、小心赋值和读取、谨慎使用指针操作以及考虑内存对齐和布局等方法，可以正确地使用位域，发挥其优势，同时确保程序的正确性和稳定性。在 C++的广阔编程世界中，位域作为一种强大的工具，可以在复杂数据结构中实现高效的内存利用和特定的数据表示。只有这样，我们才能在复杂的数据结构中精准驾驭位域，避免未定义行为，为开发高质量的 C++程序奠定坚实的基础。例如，在图像编码中，可以使用位域来表示像素的颜色值，将红、绿、蓝三个颜色通道的值压缩到较少的位数中。尽量避免使用指针操作位域。
C语言：刷题日志(1)
zm3rttqs9f的博客
09-07 1264
阶乘计算升级版 然后是几点 求整数段和 爬动的蠕虫 龟兔赛跑
哈希表的底层实现之闭散列（C++）
sqm_C的博客
09-09 798
private://有效数据个数这里我们就用std库里的vector来充当我们的底层结构，我们的哈希链表就存放到这个顺序表里就好了，_n代表我们的有效数据个数，可以先给它上个0；我们接下来讲它的各个函数。
C++ 哈希
05-24
C++ 中有许多哈希算法可供选择，其中最常用的是 STL 中提供的哈希表容器 `unordered_map` 和 `unordered_set`。 这些容器使用了 STL 中的哈希函数 `hash`，可以对各种类型的数据进行哈希。如果需要自定义哈希函数，可以通过重载 `hash` 函数来实现。 下面是一个简单的例子，演示了如何使用 `unordered_map` 存储字符串和整数之间的映射关系： ```cpp #include <iostream> #include <unordered_map> #include <string> int main() { std::unordered_map<std::string, int> map; map["apple"] = 1; map["banana"] = 2; map["cherry"] = 3; std::cout << "The number of apples is: " << map["apple"] << std::endl; // 输出 1 return 0; } ``` 注意，由于哈希表是无序的，因此在遍历哈希表时不能保证元素的顺序。如果需要按照一定的顺序遍历，可以将元素复制到一个 vector 中，然后对 vector 进行排序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值