C++ unordered关联式容器

已于 2024-03-04 11:14:56 修改
阅读量465 收藏 8
点赞数 9
分类专栏： C++ 数据结构 算法 文章标签： 哈希算法 算法
于 2023-12-25 15:57:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75404212/article/details/135201182
版权
C++ 同时被 3 个专栏收录
8 篇文章 0 订阅
订阅专栏
数据结构
5 篇文章 0 订阅
订阅专栏
算法
4 篇文章 0 订阅
订阅专栏

哈希是一种高效查询的方法，其大致思想是将每个值映射成下表并用容器存储，需要查询的时候能够在相应位置直接拿到数据，因此查询的效率是O(1)

一、unordered系列关联式容器

1.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. 它的迭代器至少是前向迭代器。

unordered_map存储的元素是pair<key,value>,通过key将pair映射到相应位置，查询的时候一般采用[  ]的方式

unordered_map模拟实现

#pragma once
#include<vector>
namespace myspace
{
	template<class T>
	struct HashFunc
	{
		size_t operator()(const T& key)
		{
			return (size_t)key;
		}
	};
	template<>
	struct HashFunc<string>
	{
		size_t operator()(const string& key)
		{
			size_t hash = 0;
			for (auto& e : key)
			{
				hash *= 31;
				hash += e;
			}
			return hash;
		}
	};
	template<class T>
	struct HashBucketNode
	{
		HashBucketNode(const T& data = T())
			:_data(data), _next(nullptr)
		{}
		HashBucketNode* _next;
		T _data;
	};
	template<class K, class V, class KeyOfValue, class HF>
	struct HBIterator;
	// 为了实现简单，在哈希桶的迭代器类中需要用到hashBucket本身，
	template<class K, class V, class KeyOfValue, class HF>
	class HashBucket
	{
		typedef HashBucketNode<V> Node;
		HF hf;
		KeyOfValue kot;
	public:
		typedef HBIterator<K, V, KeyOfValue, HF> iterator;

		HashBucket()
			:_n(0)
		{
			_ht.resize(10);
		}
		size_t BucketCount()
		{
			return _ht.size();
		}
		size_t BucketSize(const K& key)
		{
			size_t hashi = hf(key) % _ht.size();
			Node* cur = _ht[hashi];
			size_t ret = 0;
			while (cur)
			{
				++ret;
				cur = cur->_next;
			}
			return ret;
		}
		pair<iterator, bool> Insert(const V& data)
		{
			if (_n == _ht.size())
			{
				size_t newsize = _ht.size() * 2;
				vector<Node*>newht(newsize);
				for (int i = 0; i < _ht.size(); i++)
				{
					Node* cur = _ht[i];
					while (cur)
					{
						Node* next = cur->_next;
						cur->_next = nullptr;
						K key = kot(cur->_data);
						size_t hashi = hf(key) % newsize;
						if (newht[hashi])
						{
							Node* prev = newht[hashi];
							while (prev->_next)
							{
								prev = prev->_next;
							}
							prev->_next = cur;
						}
						else
						{
							newht[hashi] = cur;
						}
						cur = next;
					}
				}
				_ht.swap(newht);
				return Insert(data);
			}
			K key = kot(data);
			size_t hashi = hf(key) % _ht.size();
			Node* cur = _ht[hashi];
			if (cur)
			{
				Node* prev = nullptr;
				while (cur)
				{
					if (kot(cur->_data) == kot(data))
					{
						iterator it(cur, this);
						return make_pair(it, false);
					}
					prev = cur;
					cur = cur->_next;
				}
				Node* newnode = new Node(data);
				prev->_next = newnode;
				iterator it(newnode, this);
				++_n;
				return make_pair(it, true);
			}
			else
			{
				Node* newnode = new Node(data);
				_ht[hashi] = newnode;
				iterator it(newnode, this);
				++_n;
				return make_pair(it, true);
			}
		}
		iterator Erase(iterator pos)
		{
			pos++;
			K key = kot(pos->_data);
			size_t hashi = hf(key) % _ht.size();
			Node* cur = _ht[hashi];
			if (cur == pos->_pNode)
			{

				_ht[hashi] = nullptr;
				delete cur;
			}
			else
			{
				while (cur->_next != pos->_pNode)
				{
					cur = cur->_next;
				}
				Node* next = cur->_next->_next;
				delete cur->_next;
				cur->_next = next;
			}
			--_n;
			return pos;
		}
		size_t Count(const K& key)
		{
			size_t hashi = hf(key) % _ht.size();
			size_t ret = 0;
			Node* cur = _ht[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return 1;
				}
				cur = cur->_next;
			}
			return 0;
		}
		iterator Find(const K& key)
		{
			size_t hashi = hf(key) % _ht.size();
			Node* cur = _ht[hashi];
			while (cur)
			{
				if (cur->_data.first == key)
				{
					return iterator(cur);
				}
			}
			return end();
		}
		iterator begin()
		{
			for (int i = 0; i < BucketCount(); i++)
			{
				if (_ht[i])
					return iterator(_ht[i]);
			}
			return iterator(nullptr);
		}
		iterator end()
		{
			return iterator(nullptr);
		}
		size_t size()
		{
			size_t ret = 0;
			for (int i = 0; i < BucketCount(); i++)
			{
				Node* cur = _ht[i];
				while (cur)
				{
					++ret;
					cur = cur->_next;
				}
			}
			return ret;
		}
		bool empty()
		{
			return size() == 0;
		}
	private:
		vector<Node*> _ht;
		size_t _n;
	};

	template <class K, class V, class KeyOfValue, class HF>
	struct HBIterator
	{
		typedef HashBucket<K, V, KeyOfValue, HF> HashBucket;
		typedef HashBucketNode<V> Node;
		typedef HBIterator<K, V, KeyOfValue, HF> Self;
		KeyOfValue kot;
		HF hf;
		HBIterator(Node* pNode = nullptr, HashBucket* pHt = nullptr)
			:_pNode(pNode), _pHt(pHt)
		{}

		Self& operator++()
		{
			// 当前迭代器所指节点后还有节点时直接取其下一个节点
			if (_pNode->_next)
				_pNode = _pNode->_next;
			else
			{
				// 找下一个不空的桶，返回该桶中第一个节点
				size_t bucketNoempty = hf(kot(_pNode->_data)) % _pHt->BucketCount() + 1;
				for (; bucketNoempty < _pHt->BucketCount(); ++bucketNoempty)
				{
					if (_pNode = _pHt->_ht[bucketNoempty])
						break;
				}
			}
			return *this;
		}
		Self operator++(int)
		{
			Self temp = *this;
			++temp;
			return temp;
		}
		V& operator*()
		{
			return _pNode->_data;
		}
		V* operator->()
		{
			return &_pNode->_data;
		}
		bool operator==(const Self& it) const
		{
			return _pNode == it._pNode;
		}
		bool operator!=(const Self& it) const
		{
			return !(*this == it);
		}
		Node* _pNode;             // 当前迭代器关联的节点
		HashBucket* _pHt;         // 哈希桶--主要是为了找下一个空桶时候方便
	};
}
#include"HashBucket.h"
namespace myspace
{
	

	// unordered_map中存储的是pair<K, V>的键值对，K为key的类型，V为value的类型，HF哈希函数类型
	// unordered_map在实现时，只需将hashbucket中的接口重新封装即可
	template<class K, class V, class HF = HashFunc<K>>
	class unordered_map
	{
		struct MapKeyOfValue
		{
			const K& operator()(const pair<K, V>& data)
			{
				return data.first;
			}
		};
		typedef HashBucket<K, pair<K, V>, MapKeyOfValue, HF> HT;
		// 通过key获取value的操作
		
	public:
		typedef typename HT::iterator iterator;
	public:
		unordered_map() 
			: _ht()
		{}
		
		iterator begin() { return _ht.begin(); }
		iterator end() { return _ht.end(); }
		//
		// capacity
		size_t size()const { return _ht.size(); }
		bool empty()const { return _ht.empty(); }
		/
		// Acess
		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = _ht.Insert(pair<K, V>(key, V()));
			return (ret.first)->second;
		}
		const V& operator[](const K& key)const
		{
			pair<iterator, bool> ret = _ht.Insert(pair<K, V>(key, V()));
			return (ret.first)->second;
		}
		
		// lookup
		iterator find(const K& key) { return _ht.Find(key); }
		size_t count(const K& key) { return _ht.Count(key); }
		/
		// modify
		pair<iterator, bool> insert(const pair<K, V>& value)
		{
			return _ht.Insert(value);
		}

		iterator erase(iterator position)
		{
			return _ht.Erase(position);
		}
		
		// bucket
		size_t bucket_count() { return _ht.BucketCount(); }
		size_t bucket_size(const K& key) { return _ht.BucketSize(key); }
	private:
		HT _ht;
	};
}

2.unordered_set

unordered_set和unordered_map类似，因为他们底层都是哈希桶，即HashBucket。他们的区别是unordered_set存储的元素是key,即它的value=key,而unordered_map的value是pair<key,value>

unordered_set模拟实现

#pragma once
#include<vector>
namespace bit
{
	template<class T>
	struct HashFunc
	{
		size_t operator()(const T& key)
		{
			return (size_t)key;
		}
	};
	template<>
	struct HashFunc<string>
	{
		size_t operator()(const string& key)
		{
			size_t hash = 0;
			for (auto& e : key)
			{
				hash *= 31;
				hash += e;
			}
			return hash;
		}
	};
	template<class T>
	struct HashBucketNode
	{
		HashBucketNode(const T& data = T())
			:_data(data), _next(nullptr)
		{}
		HashBucketNode* _next;
		T _data;
	};
	template<class K, class V, class KeyOfValue, class HF>
	struct HBIterator;
	// 为了实现简单，在哈希桶的迭代器类中需要用到hashBucket本身，
	template<class K, class V, class KeyOfValue, class HF>
	class HashBucket
	{
		typedef HashBucketNode<V> Node;
		HF hf;
		KeyOfValue kot;
	public:
		typedef HBIterator<K, V, KeyOfValue, HF> iterator;

		HashBucket()
			:_n(0)
		{
			_ht.resize(10);
		}
		size_t BucketCount()
		{
			return _ht.size();
		}
		size_t BucketSize(const K& key)
		{
			size_t hashi = hf(key) % _ht.size();
			Node* cur = _ht[hashi];
			size_t ret = 0;
			while (cur)
			{
				++ret;
				cur = cur->_next;
			}
			return ret;
		}
		pair<iterator, bool> Insert(const V& data)
		{
			if (_n == _ht.size())
			{
				size_t newsize = _ht.size() * 2;
				vector<Node*>newht(newsize);
				for (int i = 0; i < _ht.size(); i++)
				{
					Node* cur = _ht[i];
					while (cur)
					{
						Node* next = cur->_next;
						cur->_next = nullptr;
						K key = kot(cur->_data);
						size_t hashi = hf(key) % newsize;
						if (newht[hashi])
						{
							Node* prev = newht[hashi];
							while (prev->_next)
							{
								prev = prev->_next;
							}
							prev->_next = cur;
						}
						else
						{
							newht[hashi] = cur;
						}
						cur = next;
					}
				}
				_ht.swap(newht);
				return Insert(data);
			}
			K key = kot(data);
			size_t hashi = hf(key) % _ht.size();
			Node* cur = _ht[hashi];
			if (cur)
			{
				Node* prev = nullptr;
				while (cur)
				{
					if (kot(cur->_data) == kot(data))
					{
						iterator it(cur, this);
						return make_pair(it, false);
					}
					prev = cur;
					cur = cur->_next;
				}
				Node* newnode = new Node(data);
				prev->_next = newnode;
				iterator it(newnode, this);
				++_n;
				return make_pair(it, true);
			}
			else
			{
				Node* newnode = new Node(data);
				_ht[hashi] = newnode;
				iterator it(newnode, this);
				++_n;
				return make_pair(it, true);
			}
		}
		iterator Erase(iterator pos)
		{
			pos++;
			K key = kot(pos->_data);
			size_t hashi = hf(key) % _ht.size();
			Node* cur = _ht[hashi];
			if (cur == pos->_pNode)
			{

				_ht[hashi] = nullptr;
				delete cur;
			}
			else
			{
				while (cur->_next != pos->_pNode)
				{
					cur = cur->_next;
				}
				Node* next = cur->_next->_next;
				delete cur->_next;
				cur->_next = next;
			}
			--_n;
			return pos;
		}
		size_t Count(const K& key)
		{
			size_t hashi = hf(key) % _ht.size();
			size_t ret = 0;
			Node* cur = _ht[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return 1;
				}
				cur = cur->_next;
			}
			return 0;
		}
		iterator Find(const K& key)
		{
			size_t hashi = hf(key) % _ht.size();
			Node* cur = _ht[hashi];
			while (cur)
			{
				if (cur->_data.first == key)
				{
					return iterator(cur);
				}
			}
			return end();
		}
		iterator begin()
		{
			for (int i = 0; i < BucketCount(); i++)
			{
				if (_ht[i])
					return iterator(_ht[i]);
			}
			return iterator(nullptr);
		}
		iterator end()
		{
			return iterator(nullptr);
		}
		size_t size()
		{
			size_t ret = 0;
			for (int i = 0; i < BucketCount(); i++)
			{
				Node* cur = _ht[i];
				while (cur)
				{
					++ret;
					cur = cur->_next;
				}
			}
			return ret;
		}
		bool empty()
		{
			return size() == 0;
		}
	private:
		vector<Node*> _ht;
		size_t _n;
	};

	template <class K, class V, class KeyOfValue, class HF>
	struct HBIterator
	{
		typedef HashBucket<K, V, KeyOfValue, HF> HashBucket;
		typedef HashBucketNode<V> Node;
		typedef HBIterator<K, V, KeyOfValue, HF> Self;
		KeyOfValue kot;
		HF hf;
		HBIterator(Node* pNode = nullptr, HashBucket* pHt = nullptr)
			:_pNode(pNode), _pHt(pHt)
		{}

		Self& operator++()
		{
			// 当前迭代器所指节点后还有节点时直接取其下一个节点
			if (_pNode->_next)
				_pNode = _pNode->_next;
			else
			{
				// 找下一个不空的桶，返回该桶中第一个节点
				size_t bucketNoempty = hf(kot(_pNode->_data)) % _pHt->BucketCount() + 1;
				for (; bucketNoempty < _pHt->BucketCount(); ++bucketNoempty)
				{
					if (_pNode = _pHt->_ht[bucketNoempty])
						break;
				}
			}
			return *this;
		}
		Self operator++(int)
		{
			Self temp = *this;
			++temp;
			return temp;
		}
		V& operator*()
		{
			return _pNode->_data;
		}
		V* operator->()
		{
			return &_pNode->_data;
		}
		bool operator==(const Self& it) const
		{
			return _pNode == it._pNode;
		}
		bool operator!=(const Self& it) const
		{
			return !(*this == it);
		}
		Node* _pNode;             // 当前迭代器关联的节点
		HashBucket* _pHt;         // 哈希桶--主要是为了找下一个空桶时候方便
	};
}
#pragma once
#include"HashBucket.h"
namespace bit
{
	template<class K, class HF = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfValue
		{
			const K& operator()(const K& data)
			{
				return data;
			}
		};
		typedef HashBucket<K, K, SetKeyOfValue, HF> HT;
		// 通过key获取value的操作
		
	public:
		typedef typename  HT::iterator iterator;
	public:
		unordered_set() : _ht()
		{}
		
		iterator begin() { return _ht.begin(); }
		iterator end() { return _ht.end(); }
		
		// capacity
		size_t size()const { return _ht.size(); }
		bool empty()const { return _ht.empty(); }
		///
		// lookup
		iterator find(const K& key) { return _ht.Find(key); }
		size_t count(const K& key) { return _ht.Count(key); }
		/
		// modify
		pair<iterator, bool> insert(const K& value)
		{
			return _ht.Insert(value);
		}

		iterator erase(iterator position)
		{
			return _ht.Erase(position);
		}
		
		// bucket
		size_t bucket_count() { return _ht.BucketCount(); }
		size_t bucket_size(const K& key) { return _ht.BucketSize(key); }
	private:
		HT _ht;
	};
}

二、哈希冲突

处理哈希冲突的方法一般是闭散列和开散列，这里实现的是开散列

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

只是寻找下一个空位置又有不同的方法，包括线性探测和二次探测等L:

 开散列:选择在相应位置挂链表（如果同一位置元素过多则选择挂红黑树），映射到相同位置的元素直接在链表上尾插即可

迷梦y
关注
  • 9
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++进阶：关联式容器
欧尼酱的技术园
07-29 393
文章目录前言一，关联式容器1.键值对2. 关联式容器二，树形结构的关联式容器2.1 set2.1.1 set的使用案例2.2 map2.2.1 map的使用案例2.3 multiset2.3.1 multiset的使用2.4 multimap2.4.1 multimap的介绍2.4.2 multimap的使用总结 前言 今天介绍几种关联式容器，这几种关联式容器在C++中很常用，且很相似，同学们要仔细分辨。 一，关联式容器 1.键值对 键值对是用来表示具有一一对应的关系的一种结构，该结构中一般只包含两个.
C++顺序容器，容器适配器，关联容器的操作
10-18
包括顺序容器vector，string，list，forward，deque ，array；容器适配器stack，queue，priority_queue以及关联容器map，set，multimap，unordered_multimap等的增删查改操作。
C++:关联式容器：unordered_map
qq_59535638的博客
06-08 4921
unordered_ map 的特性，常用接口的使用
【C++】unordered 系列关联式容器
在这个博客里，我将分享我的技术见解、项目经验和学习笔记，内容涵盖C++编程、数据结构与算法、高性能计算、分布式系统等。
04-09 1435
在内部，unordered_map 没有对 按照任何特定的顺序排序，为了能在常数范围内找到 key 所对应的 value，unordered_map 将相同哈希值的键值对放在相同的桶中。
【C++】哈希（unordered系列关联式容器）
学了就忘是正常现象
03-29 926
C++的unordered_set和unordered_map。很强的数据结构。
[C++]unordered系列关联式容器
Protein_zmm的博客
09-03 352
unordered系列的基本结构及其使用说明
C++STL关联式容器map
weixin_43956958的博客
05-19 385
文章目录C++ STL关联式容器种类map容器创建map容器map容器的成员方法获取键对应值的方法 C++ STL关联式容器种类 容器名称 特点 map 定义在 头文件中，使用该容器存储的数据，其各个元素的键必须是唯一的（即不能重复），该容器会根据各元素键的大小，默认进行升序排序（调用 std::less）。 set 定义在 头文件中，使用该容器存储的数据，各个元素键和值完全相同，且各个元素的值不能重复（保证了各元素键的唯一性）。该容器会自动根据各个元素的键（其实也就是元素值）的大小
C++--unordered系列关联式容器简单介绍及应用代码
赵铁蛋的博客
04-05 386
声明：本人所有测试代码环境都为vs2017 本文目录1. unordered_map2. unordered_multimap3. unordered_set4. unordered_multiset5. 解题应用 在 C++11 中，STL 提供了 4 个 unordered 系列的关联式容器，这四个容器底层结构都是哈希桶，所以查找效率都非常快(O(1))。分别是：unordered_map 、...
C++ 关联容器
恋恋风辰的技术博客
01-14 670
之前我们介绍过顺序容器，list, vector, queue等，这一篇介绍关联容器, C++关联容器主要有两大类，map和set。 map map主要是用来管理key,value类型的结构的。 void use_map() { map<string, size_t> word_count; string word; while (cin >> word) { word_count[word]++; } for (co
4-1 C++ 中的关联式容器
chumingqian的博客
04-18 396
在《C++ STL容器》一节中讲到，C++ 容器大致分为 2 类，即序列式容器和关联式容器。其中，序列式容器（包括 array、vector、list、deque 和 forward_list）已经在前面章节中做了详细的介绍，从本节开始，将逐个对 C++ STL 标准库中的所有关联式容器做详细的讲解。 提到 C++ STL 关联式容器，读者可能会以下一些疑问： 关联式容器是什么，具有哪些特点？ 和序列式容器相比，关联式容器有什么不同？ 关联式容器的种类有哪些？ 别急，读完本文，这些疑问都会迎刃而解。 C++
C++实现关联规则
06-30
C++提供了多种优化手段，如使用STL容器（如set和unordered_set）的特性，或者使用多线程（如std::thread或OpenMP）来并行处理数据。 在C++中实现关联规则需要理解数据挖掘的基本原理，同时熟练掌握C++编程技巧和库...
STL.rar_c++ 容器使用
09-24
3. **关联容器(如Set、Map、Multiset、Multimap)**：这些容器中的元素是有序的，并且每个元素都有一个键值。Set和Multiset存储唯一元素，Map和Multimap存储键值对，其中Multiset和Multimap允许键值重复。插入和查找...
C++之STL标准库容器成员一览表.pdf
08-25
这些关联容器都提供了基本的成员函数，如insert()、erase()、find()、count()等，用于对容器中的元素进行操作。 容器成员 STL容器都提供了一些基本的成员变量和成员函数，用于对容器中的元素进行操作。这些成员...
14 卡尔曼滤波及代码实现
qq_44175983的博客
06-29 974
卡尔曼滤波是一种利用线性系统状态方程，通过系统输入输出观测数据，对系统状态进行最优估计的算法。由于观测数据包括系统中的噪声和干扰的影响，所以最优估计也可看作是滤波过程。预测是根据上一时刻的状态量，由状态方程预测出下一时刻的状态量。加入观测，对预测值进行更新校正，得到最优后验估计。，以及状态量误差协方差的先验估计矩阵。以雷达追踪目标为背景，系统的状态方程为。是过程噪声，服从高斯分布，时刻的预测值，结合第。时刻的观测值，得到第。是上一时刻的最优估计。是过程噪声的协方差，是观测噪声的协方差。这是没有加观测值的。
风控图算法之中心性算法（小数据集Python版）
LUyan10086的博客
06-28 930
图算法在金融风控领域的应用已经超越了传统的社区发现技术，这些技术曾被主要用于识别和分析欺诈性行为模式，例如黑产团伙。当前，一系列图统计算法，包括介数中心性（Betweenness）、核（Kcore）、以及PageRank等，正逐渐展现出它们在风险评估和管理中的重要作用。这些算法不仅作为辅助判别工具，帮助揭示交易网络中的潜在风险点，而且在识别网络中的核心和影响力节点方面发挥着关键作用。通过精确识别这些核心节点，金融机构能够更有效地监测和防范可能的风险传播路径，从而增强整体的风险控制框架。
C语言经典例题-7
zhongziqia的博客
06-28 502
变种水仙花数 - Lily Number：把任意的数字，从中间拆分成两个数字，比如1461 可以拆分成（1和461）,（14和61）,（146和1),如果所有拆分后的乘积之和等于自身，则是一个Lily Number。学生信息管理系统是学校教学管理的重要工具，现有一名学生基本信息如下：姓名-Jack，年龄-18，性别-Man，请按照输出样例的格式输出该学生的信息。一行，三角形周长和面积（保留两位小数），中间用一个空格隔开，输出具体格式详见输出样例。输出分为三行，分别为标题行，分隔行，信息行。
【代码随想录算法训练营第五十三天|739.每日温度、496.下一个更大元素I、503.下一个更大元素II】
最新发布
weixin_46281930的博客
06-29 377
因为这里需要的是每个数组元素右边第一个比他大的元素的间隔，因此单调栈是用来在遍历数组的时候存放还没有找到比他大的元素的下标，如果当前的元素比栈顶的元素大，那么就在结果对应的下标的位置记录下这个间隔，并且把该栈顶元素出栈，否则就入栈，等待后续的第一个比他大的元素出现。先和上面一样正常的向右找最近的更大元素，然后全部遍历完之后，再根据还在单调栈中（这些就是在右边没有找到下一个更大元素的元素）的最大索引，也就是栈顶的元素在nums中再从左往右和栈顶的索引对应元素对比一次大小。
c++ 类容器 unordered_set
09-15
unordered_set是C++标准库中的一种关联容器，属于unordered系列容器。unordered_set使用哈希表来存储元素，可以实现快速的插入、删除和查找。unordered_set中的元素是唯一的，不允许重复。使用unordered_set需要包含...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

迷梦y

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

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

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

打赏作者

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

抵扣说明：

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

余额充值