c++逆天改命进阶--哈希表

最新推荐文章于 2024-06-30 13:08:33 发布
最新推荐文章于 2024-06-30 13:08:33 发布
阅读量297 收藏
点赞数 1
分类专栏： c++逆天改命 文章标签： c++ 散列表 哈希算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/btzxlin/article/details/125182054
版权
本文介绍了C++11中unordered_set和unordered_map的高效使用，比较了它们与红黑树容器在查询性能上的改进，并通过实例演示了哈希表在查找和去重操作中的优势。还讨论了直接定址法和两种散列冲突解决方法——闭散列与开散列的实现原理。
摘要由CSDN通过智能技术生成

1.unordered系列关联式容器

在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 ，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑
树结构的关联式容器使用方式基本类似，只是其底层结构不同。

image-20220606161340184

2.unordered_set和unordered_map的练习使用

#include <iostream>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <string>
#include <vector>
#include <time.h>
#include <set>
using namespace std;

void test_unordered_set1()
{
	unordered_set<int> us;
	us.insert(2);
	us.insert(1);
	us.insert(2);
	us.insert(3);
	us.insert(5);
	us.insert(6);
	us.insert(2);
	us.insert(6);
	unordered_set<int>::iterator it = us.begin();
	while (it != us.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

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

	//auto pos = us.find(2);
	auto pos = us.find(12);
	//我们直到在算法里面也有一个find 那么这两个find有什么区别呢？
	//auto pos = find(us.begin(), us.end(), 2);
	//这是一个通用的算法，但是这是一种暴力查找，O(N),效率低
	//而unordered_set里面自带的find(),在查找的时候利用了哈希的特性，效率高O(1)
	if (pos != us.end())
	{
		cout << "找到了" << endl;
	}
	else
	{
		cout << "找不到了" << endl;
	}
}

void test_unordered_map1()
{
	unordered_map<string, string> dict;
	dict.insert(make_pair("happy", "开心的"));
	dict.insert(make_pair("left", "左边"));
	auto it = dict.begin();
	while (it != dict.end())
	{
		cout << it->first << ":" << it->second << endl;
		++it;
	}
}

//下面我们在release版本下面对于set和unordered_set进行效率的对比
void test_op()
{
	int N = 1000000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));
	while (N--)
	{
		v.push_back(rand());
	}

	set<int> s;
	unordered_set<int> us;
	size_t begin1 = clock();
	for (auto e : v)
	{
		s.insert(e);
	}
	size_t end1 = clock();
	size_t begin2 = clock();

	for (auto e : v)
	{
		us.insert(e);
	}
	size_t end2 = clock();
	cout << "s:" << end1 - begin1 << endl;
	cout << "us:" << end2 - begin2 << endl;
	
}


int main()
{
	//test_unordered_set1();
	//test_unordered_map1();
	test_op();
	return 0;
}

image-20220606164512199

3.在长度 2N 的数组中找出重复 N 次的元素

image-20220606170052828

class Solution {
public:
    int repeatedNTimes(vector<int>& nums) 
    {
        unordered_map<int,int> countMap;//用来统计每个数字出现的次数
        for(auto e: nums)
        {
            countMap[e]++;//实际上调用的是insert，不存在就插入pair(e,0)，然后把0++变成1，存在就把second++
        }
        for(auto& e : countMap)//遍历，直到找到出现n次的元素
        {
            if(e.second == nums.size()/2)
            {
                return e.first;
            }

        }
        return 0;//理论上不可能执行到这一步，但是不写会报错，必须每条路径都有返回值
    }
};

4.两个数组的交集

image-20220606170850091

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) 
    {
        //先利用set去重并排升序
        set<int> s1;
        set<int> s2;
        for(auto e : nums1)
        {
            s1.insert(e);
        }
        for(auto e : nums2)
        {
            s2.insert(e);
        }
        auto ps1 = s1.begin();
        auto ps2 = s2.begin();
        vector<int> Vret;
        //双指针
        while(ps1 != s1.end() && ps2 != s2.end())
        {
            //不相等，小的指针向后走
            if(*ps1 < *ps2)
            {
                ++ps1;
            }
            else if(*ps1 > *ps2)
            {
                ++ps2;
            }
            //相等，说明是交集，放进Vret里，两个指针一起向后走，直到其中一个走到空
            else
            {
                Vret.push_back(*ps1);
                ++ps1;
                ++ps2;
            }
        }
        return Vret;

    }

5.哈希概念

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

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

  • 插入元素

    根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放

  • 搜索元素

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

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

6.直接定址法

取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B

字符串中的第一个唯一字符

image-20220606184742104

class Solution {
public:
    int firstUniqChar(string s) 
    {
        int count[26] = {0};//用来存放26个小写字母出现的次数
        for(auto ch : s)
        {
            count[ch - 'a']++;
        }
        for(int i = 0;i<s.size();++i)
        {
            if(count[s[i]-'a']==1)
            {
                return i;
            }
        }
        return -1;

    }
};

缺陷：

  1. 给你一组数据范围很大，会浪费很多空间
  2. 不能处理浮点数，字符串等数据

7.除留余数法

image-20220606191830261

那么，如何解决哈希冲突呢？

image-20220606201536493

7.1闭散列

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

namespace CloseHash
{
	enum State
	{
		EMPTY,
		EXITS,
		DELETE
	};
	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		State _state = EMPTY;
	};
	template <class K>
	struct Hash
	{
		size_t operator()(const K& key)
		{
			return key;
		}
	};
	template<>
	struct Hash<string>
	{
		size_t operator()(const string& s)
		{
			size_t value = 0;
			//BKDR Hash
			for (auto ch : s)
			{
				value += ch;
				value *= 131;
			}
			return value;
		}
		
	};


	template<class K, class V, class HashFunc = Hash<K>>
	class HashTable
	{
	public:
		bool Insert(const pair<K, V>& kv)
		{
			HashData<K, V>* ret = Find(kv.first);
			if (ret)
			{
				return false;
			}
			if (_table.size() == 0)//初次插入直接分配10个空间
			{
				_table.resize(10);
			}
			//负载因子越大，冲突概率越大，效率越低
			//负载因子越小，浪费空间越多。我们这里让负载因子大于0.7就增容
			else if ((double)_n / (double)_table.size() > 0.7)
			{
				//增容
				HashTable<K, V> newHT;
				newHT._table.resize(_table.size() * 2);//新建一个哈希表，扩容到原来的2倍
				for (auto& e : _table)//遍历原表，把存在的数据插入到新表
				{
					if (e._state == EXITS)
					{
						newHT.Insert(e._kv);
					}
				}
				_table.swap(newHT._table);//交换两表
			}
			HashFunc hf;
			size_t start = hf(kv.first) % _table.size();//找到插入的位置
			size_t index = start;
			size_t i = 1;
			while (_table[index]._state != EMPTY)//如果当前位置不为空就要向后找位置
			{
				//线性探测或二次探测
				index = start + i;
				index %= _table.size();//如果不加这一句，可能会导致越界(index>_table.size())
				++i;
			}
			_table[index]._kv = kv;
			_table[index]._state = EXITS;
			++_n;
			return true;
		}
		HashData<K, V>* Find(const K& key)
		{
			if (_table.size() == 0)
			{
				return nullptr;
			}
			HashFunc hf;
			size_t i = 1;
			size_t start = hf(key) % _table.size();
			int index = start;
			while (_table[index]._state != EMPTY)
			{
				if (_table[index]._state == EXITS 
					&& _table[index]._kv.first == key)
				{
					return &_table[index];
				}
				index = start + i;
				index %= _table.size();
				++i;
			}
			return nullptr;

		}
		bool Erase(const K& key)
		{
			HashData<K, V>* ret = Find(key);
			if (ret == nullptr)
			{
				return false;
			}
			else
			{
				ret->_state = DELETE;
				return true;
			}
		}
	private:
		vector<HashData<K, V>> _table;
		size_t _n = 0;//存储数据的有效个数
	};
	void TestHashTable1()
	{
		int a[] = { 1, 5, 10, 100000, 100, 18, 15, 7, 40 };
		HashTable<int, int> ht;
		for (auto e : a)
		{
			ht.Insert(make_pair(e, e));
		}
		auto ret = ht.Find(100);
		if (ret)
		{
			cout << "找到了" << endl;
		}
		else
		{
			cout << "没找到" << endl;
		}
		ht.Erase(100);
		ret = ht.Find(100);
		if (ret)
		{
			cout << "找到了" << endl;
		}
		else
		{
			cout << "没找到" << endl;
		}
	}

	void TestHashTable2()
	{
		string a[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "橘子", "苹果" };
		HashTable<string, int> ht;
		for (auto str : a)
		{
			auto ret = ht.Find(str);
			if (ret)
			{
				ret->_kv.second++;
			}
			else
			{
				ht.Insert(make_pair(str, 1));
			}
		}

	}
}

7.2开散列

image-20220608105143545

namespace OpenHash
{
	template <class K>
	struct Hash
	{
		size_t operator()(const K& key)
		{
			return key;
		}
	};
	template<>
	struct Hash<string>
	{
		size_t operator()(const string& s)
		{
			size_t value = 0;
			//BKDR Hash
			for (auto ch : s)
			{
				value += ch;
				value *= 131;
			}
			return value;
		}

	};
	template <class K, class V>
    struct HashNode
	{
		pair<K, V> _kv;
		HashNode<K, V>* _next;
		HashNode(const pair<K, V>& kv)
			:_kv(kv)
			,_next(nullptr)
		{}
	};
	template <class K, class V, class HashFunc = Hash<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		bool Insert(const pair<K, V> kv)
		{
			if (Find(kv.first))
			{
				return false;
			}
			HashFunc hf;
			if (_n == _table.size())//负载因子到1时开始扩容
			{
				vector<Node*> newtable;
				size_t newsize = _table.size() == 0 ? 8 : _table.size() * 2;
				newtable.resize(newsize, nullptr);
				//遍历旧表中非空节点，重新计算位置头插放到新表
				for (int i = 0;i < _table.size();++i)
				{
					if (_table[i])
					{
						Node* cur = _table[i];
						while (cur)
						{
							Node* next = cur->_next;
							size_t index = hf(cur->_kv.first) % newtable.size();
							//头插
							cur->_next = newtable[index];
							newtable[index] = cur;
							cur = next;
						}
						_table[i] = nullptr;
					}
				}
				_table.swap(newtable);
			}
			size_t index = hf(kv.first) % _table.size();
			Node* newNode = new Node(kv);
			newNode->_next = _table[index];
			_table[index] = newNode;
			++_n;
			return true;
		}
		Node* Find(const K& key)
		{
		
			if (_table.size() == 0)
			{
				return nullptr;
			}
			HashFunc hf;
			size_t index = hf(key) % _table.size();
			if (_table[index])
			{
				Node* cur = _table[index];
				while (cur)
				{
					if (cur->_kv.first == key)
					{
						return cur;
					}
					else
					{
						cur = cur->_next;
					}
				}
			}
			return nullptr;

		}
		bool Erase(const K& key)
		{
			if (_table.size() == 0)
			{
				return false;
			}
			HashFunc hf;
			size_t index = hf(key) % _table.size();
			Node* cur = _table[index];
			Node* prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (cur == _table[index])
					{
						_table[index] = nullptr;
					}
					else
					{
						prev->_next = next;
					}
					delete cur;
					--_n;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			return false;
		}
	private:
		vector<Node*> _table;
		size_t _n = 0;
	};
	void TestHashTable1()
	{
		int a[] = { 1, 5, 30, 100000, 100, 18, 15, 7, 40, 44 };
		HashTable<int, int> ht;
		for (auto e : a)
		{
			ht.Insert(make_pair(e, e));
		}
		ht.Insert(make_pair(25, 25));
	}
	void TestHashTable2()
	{
		string a[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "橘子", "苹果" };
		HashTable<string, int> ht;
		for (auto str : a)
		{
			auto ret = ht.Find(str);
			if (ret)
			{
				ret->_kv.second++;
			}
			else
			{
				ht.Insert(make_pair(str, 1));
			}
		}
	}
}
逃跑的机械工
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ 哈希表
weixin_44208324的博客
03-21 274
哈希表(Hash tabel,也叫散列表)，是根据关键字值(key)直接进行访问的数据结构，它通过把关键字值映射到表中一个位置(数组下标)来直接访问，以加快查找关键字值的速度。这个映射函数叫做哈希(散列)函数，存放记录的数组叫做哈希(散列)表。 给定表M，存放函数(key)，对任意的关键字值key，代入函数后若能得到包含该关键字的表中地址，称表M为哈希(Hash)表，函数f(key)为哈希(Has...
Hash表（C++实现）
lovecontry
08-20 444
哈希表的几个概念： 映像：由哈希函数得到的哈希表是一个映像。 冲突：如果两个关键字的哈希函数值相等，这种现象称为冲突。 处理冲突的几个方法： 1、开放地址法：用开放地址处理冲突就是当冲突发生时，形成一个地址序列，沿着这个序列逐个深测，直到找到一个“空”的开放地址，将发生冲突的关键字值存放到该地址中去。 例如：hash(i)=(hash(key)+d(i)) MOD m (i=1,2,3,...
【C++】哈希表
最新发布
m0_74808907的博客
06-30 1419
一文带你由浅入深掌握哈希表
C++ 哈希表
Han同学
02-26 2776
C++哈希表
哈希表（c++）
zjq_love的博客
09-13 313
最好的情况是：每个哈希桶中刚好挂一个节点，再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功。1.桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，
c++之哈希表
qq_45274913的博客
11-21 587
题目描述： 给定一个字符串 S，请你找出其中不含有重复字符的最长子串（与最长子序列进行区分）的长度。 思路：递增地枚举子串地初始位置，则最长子串的结束位置是不递减的。因此可以使用滑动窗口进行解题，定义两个指针分别指向子串的起始和终止位置，定义一个哈希表进行字串中元素是否重复的判断。 C++ STL unordered_set无序哈希基本操作（本题）： 创建：std::unordered_set<类型> hash_set（名称） 插入：hash_set.insert() 查找值为key
精品资料系列2021-（逆天改命）漫画版.pdf
05-20
精品资料系列2021-（逆天改命）漫画版.pdf
《哪吒》或一举登上国产电影票房总榜TOP3，国产动画电影“逆天改命”？-0807-安信证券-15页.pdf
07-29
《哪吒》的成功为中国国产动画电影带来了巨大的希望和启示，其票房表现的强劲，有望将国产动画推向新的高度。2019年中国电影市场出现了罕见的票房负增长，8年来首次下滑，暑期档更是受到多部电影撤档、改档的影响，...
毕业设计-写给程序员的电子书逆天改命启舰的100条程序员人生建议.zip
04-25
这里为你收集整理了关于毕业设计、课程设计可参考借鉴的资料一份，质量非常高，如果你投入时间去研究几天相信肯定对你有很大的帮助。到时候你会回来感谢我的。 本资源是经过本地编译测试、可打开、可运行的项目、...
穷人如何改命？.docx
03-18
通过上述分析可以看出，《穷人如何改命？》这篇文档围绕着贫困环境下的心理建设、教育方式的选择以及个人提升策略等方面展开了深入探讨。这些知识点不仅对于身处困境的人来说具有指导意义，也为我们理解社会现象、...
c++ 哈希表
Hedenghui777的博客
10-26 545
文章目录前言一、什么是哈希/散列？二、什么是哈希冲突？如何解决1.开放定制法(闭散列)2.拉链法(开散列)三、如果哈希表中冲突得很厉害怎么办？四、unordered_map和unordered_set跟map/set的区别？总结面试题： 前言 在学习完map和set后，我们会惊讶于它的效率O(logn)。 但是unordered_map和unordered_set的效率是O(1)，而它的底层原理就是哈希表 一、什么是哈希/散列？ 构造一种存储结构，通过某种函数使元素的存储位置与它的关键码之间能够建立一一映
c++哈希表
qq_58291701的博客
02-21 2670
哈希表 一、概念 1.散列表，最有用的基本数据结构之一。是根据关键码的值直接进行访问的数据结构，散列表的实现常常叫做散列（hasing）。 2.散列技术是在通过记录的存储位置和它的关键字之间建立一个确定的对应关系 f ,使得每个关键字 key 都对应一个存储位置 f(key)。 3.而2中的f就是所谓的哈希函数。 二、散列函数的构造方法 直接定址法 就是通过数据本身产生线性的映射关系 f(key) = a*key+b 数字分析法 分析关键字，选取部分或者对部分位移、叠加。如学号、班号等。 折叠法 将关键字从
C++哈希表
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-19 225
槽总数的选择 1.关键码范围较小 2.关键码范围较大 简单的哈希函数 冲突解决策略 3.开哈希法 4.闭哈希法 1.哈希: 把关键码值映射到表中的位置来访问记录的过程 2.哈希函数： 将关键码值映射到位置的函数 3.槽： 哈希表中的一个位置 4.冲突： 不同的关键码经过哈希函数哈希后，映射到相同槽的情况 5.探查序列： 冲突解决策略的闭哈希方法中，如果基位置冲突，需要根据探查函数查找下一个空槽，这个过程产生的序列加上基位置组成了某个关键码的探查序列 6.基本聚集： 在探查函数的设计中，如果不同基位置关键码产
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

逃跑的机械工

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值