【C++从0到1】第十九篇：哈希（上）

最新推荐文章于 2024-03-18 10:45:14 发布
最新推荐文章于 2024-03-18 10:45:14 发布
阅读量598 收藏 10
点赞数 15
分类专栏： C++ 文章标签： 哈希算法 c++ 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52809807/article/details/124947410
版权

文章目录

一、unordered系列关联式容器

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

1.1 unordered_map

1.1.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. 它的迭代器至少是前向迭代器
  7. VS map：unorder_xxx遍历不按key排序，是一个单向迭代器。

1.1.2 unordered_map的接口说明

  1. unordered_map的构造
    在这里插入图片描述
  2. unordered_map的容量
    在这里插入图片描述
  3. unordered_map的迭代器
    在这里插入图片描述
  4. unordered_map的元素访问
    在这里插入图片描述
    注意：该函数中实际调用哈希桶的插入操作，用参数key与V()构造一个默认值往底层哈希桶中插入，如果key不在哈希桶中，插入成功，返回V()，插入失败，说明key已经在哈希桶中，将key对应的value返回。
  5. unordered_map的查询
    在这里插入图片描述
  6. unordered_map的修改操作
    在这里插入图片描述
  7. unordered_map的桶操作
    在这里插入图片描述
    在这里插入图片描述

1.2 unordered_set

在这里插入图片描述
在这里插入图片描述

1.3 在线OJ

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
方法一：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> s1;
        unordered_set<int> s2;
        //去重
        for(auto& e : nums1)
        {
            s1.insert(e);
        }

        for(auto& e : nums2)
        {
            s2.insert(e);
        }
        //遍历
        vector<int> ret;
        for(auto& e : s1)
        {
            if(s2.find(e) != s2.end())
                ret.push_back(e);
        }
        return ret;
    }
};

方法二：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) 
    {
        set<int> s1;
        set<int> s2;

        for(auto&e : nums1)
        {
            s1.insert(e);
        }

        for(auto&e : nums2)
        {
            s2.insert(e);
        }

        auto it1 = s1.begin();
        auto it2 = s2.begin();
        vector<int> ret;
        while(it1 != s1.end() && it2 != s2.end())
        {
            if(*it1 < *it2)
            {
                ++it1;
            }
            else if(*it1 > *it2)
            {
                ++it2;
            }
            else
            {
                ret.push_back(*it1);
                ++it1;
                ++it2;
            }
        }
        return ret;
    }
};

二、底层结构

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

2.1 哈希概念

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

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

当向该结构中：

  • 插入元素
    根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
  • 搜索元素
    对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功,该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)

例如：数据集合{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小
在这里插入图片描述
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快 问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？

2.2 哈希冲突

对于两个数据元素的关键字 keyi和keyj (i != j)，有keyi != keyj，但有：Hash( ) == Hash( )，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

发生哈希冲突该如何处理呢?

2.3 哈希函数

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

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

常见哈希函数

  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为随机数函数。通常应用于关键字长度不等时采用此法
  6. 数学分析法–(了解)
    设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如
    在这里插入图片描述
    假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是 相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现 冲突，还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等方法。

数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况
注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

2.4 哈希冲突解决

解决哈希冲突两种常见的方法是：闭散列和开散列

2.4.1 闭散列

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

  1. 线性探测
    线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
    • 插入
      通过哈希函数获取待插入元素在哈希表中的位置
      如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探
      测找到下一个空位置，插入新元素
      在这里插入图片描述
    • 删除
      采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。

思考：哈希表什么情况下进行扩容？如何扩容？
在这里插入图片描述
线性探测优点：实现非常简单，

线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低。如何缓解呢？

  1. 二次探测
    在这里插入图片描述

因此：闭散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。
线性探测的实现

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

namespace CloseHash
{
	enum Status
	{
		EXIST,
		EMPTY,
		DELETE
	};

	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		Status _status = EMPTY;//设置状态值
	};

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

	template<>
	struct Hash<string>
	{
		size_t operator()(const string& key)
		{
			size_t ret = 0;
			for (auto& ch : key)
			{
				ret *= 31;
				ret += ch;
			}
			return ret;
		}
	};

	template<class K, class V, class HashFunc = Hash<K>>
	class HashTable
	{
	public:
		bool erase(const K& key)
		{
			HashData<K, V, HashFunc>* ret = find(key);
			if (ret == nullptr)
			{
				return false;
			}
			//找到了将位置状态置为删除
			else
			{
				ret->_status = DELETE;
				--_n;
				return true;
			}
		}

		HashData<K, V>* find(const K& key)
		{
			if (_table.size() == 0)
			{
				return nullptr;
			}
			HashFunc ht;
			size_t start = ht(key) % _table.size();
			size_t i = 0;
			size_t index = start;
			while (_table[index]._status != EMPTY)
			{
				if (_table[index]._kv.first == key && _table[index]._status == EXIST)
				{
					return &_table[index];
				}
				++i;
				//index = start + i;
				index = start + i * i;
				index %= _table.size();
			}
			return nullptr;
		}

		bool insert(const pair<K, V>& kv)
		{
			HashData<K, V>* ret = find(kv.first);
			if (ret != nullptr)
			{
				return false;
			}
			//负载因子0.7，就扩容：填入元素个数/列表长度
			//负载因子越低，冲突概率越低，效率越高，空间浪费越多
			//负载因子越高，冲突概率就越高，效率就低，浪费空间越少
			if (_table.size() == 0 || _n * 10 / _table.size() >= 7)
			{
				size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
				HashTable<K, V> newHT;
				newHT._table.resize(newSize);
				for (size_t i = 0; i < _table.size(); ++i)
				{
					if (_table[i]._status == EXIST)
					{
						newHT.insert(_table[i]._kv);
					}
				}
				_table.swap(newHT._table);
			}
			HashFunc ht;
			size_t start = ht(kv.first) % _table.size();//映射起始位置
			size_t i = 0;
			size_t index = start;
			//线性探测or二次探测
			while (_table[index]._status == EXIST)
			{
				++i;
				//index = start + i;//线性探测
				index = start + i * i;//二次探测
				index %= _table.size();
			}

			_table[index]._kv = kv;
			_table[index]._status = EXIST;
			++_n;

			return true;
		}

	private:
		vector<HashData<K, V>> _table;
		size_t _n = 0;
	};
}

2.4.2 开散列

  1. 开散列概念
    开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
    在这里插入图片描述
    在这里插入图片描述
    从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素

  2. 开散列实现

namespace LinkHash
{
	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>
	struct Hash
	{
		size_t operator()(const K& key)
		{
			return key;
		}
	};

	template<>
	struct Hash<string>
	{
		size_t operator()(const string& key)
		{
			size_t ret = 0;
			for (auto& ch : key)
			{
				ret *= 31;
				ret += ch;
			}
			return ret;
		}
	};

	template<class K, class V, class HashFunc = Hash<K>>
	class HashTable
	{
		typedef HashNode<K, V> Node;
	public:
		Node* find(const K& key)
		{
			if (_table.size() == 0)
				return nullptr;
			HashFunc hf;
			size_t index = hf(key) % _table.size();
			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.empty())
			{
				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 (prev == nullptr)//头删
					{
						_table[index] = cur->_next;
					}
					else//中间删除
					{
						prev->_next = cur->_next;
					}
					delete cur;
					--_n;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}//end of whlie
			return false;
		}

		bool insert(const pair<K, V>& kv)
		{
			Node* ret = find(kv.first);
			if (ret)
			{
				return false;
			}
			HashFunc hf;
			if (_n == _table.size())
			{
				size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
				vector<Node*> newTable;
				newTable.resize(newSize);

				for (size_t i = 0; i < _table.size(); ++i)
				{
					Node* cur = _table[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t index = hf(cur->_kv.first) % newSize;
						cur->_next = newTable[index];
						newTable[index] = cur;
						cur = next;
					}
				}
				swap(_table, newTable);
			}
			size_t index = hf(kv.first) % _table.size();
			Node* newNode = new Node(kv);
			newNode->_next = _table[index];
			_table[index] = newNode;

			++_n;
			return true;
		}

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

三、模拟实现

3.1 哈希表的改造

namespace LinkHash
{
	template<class T>
	struct HashNode
	{
		T _data;
		HashNode<T>* _next;

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

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

	template<>
	struct Hash<string>
	{
		size_t operator()(const string& key)
		{
			size_t ret = 0;
			for (auto& ch : key)
			{
				ret *= 31;
				ret += ch;
			}
			return ret;
		}
	};

	//前置声明
	template<class K, class T, class KeyOfT, class HashFunc>
	class HashTable;
	template<class K, class T, class Ref, class Ptr, class KeyOfT, class HashFunc = Hash<K>>
	struct __HTIterator
	{
		typedef HashNode<T> Node;
		typedef __HTIterator<K, T, Ref, Ptr, KeyOfT, HashFunc> Self;
		Node* _node;
		HashTable<K, T, KeyOfT, HashFunc>* _pht;

		__HTIterator(Node* node, HashTable<K, T, KeyOfT, HashFunc>* pht)
			:_node(node)
			,_pht(pht)
		{}

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

		Ptr operator->()
		{
			return &_node->_data;
		}
		
		Self& operator++()
		{
			if (_node->_next)//当前桶下面还有结点
			{
				_node = _node->_next;
			}
			//当前桶下面没有结点
			else
			{
				KeyOfT kot;
				HashFunc hf;
				size_t index = hf(kot(_node->_data)) % _pht->_table.size();
				++index;
				//找到下一个桶
				while (index <_pht->_table.size())
				{
					if (_pht->_table[index])
					{
						break;
					}
					else
					{
						++index;
					}
				}
				if (index == _pht->_table.size())
				{
					_node = nullptr;
				}
				else
				{
					_node = _pht->_table[index];
				}
			}
			return *this;
		}

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

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

	
	template<class K, class T, class KeyOfT, class HashFunc = Hash<K>>
	class HashTable
	{
		typedef HashNode<T> Node;
		typedef HashTable<K, T, KeyOfT, HashFunc> Self;
		//声明为友元类
		template<class K, class T, class Ref, class Ptr, class KeyOfT, class HashFunc>
		friend struct __HTIterator;
	public:
		
		typedef __HTIterator<K, T, T&, T*, KeyOfT, HashFunc> iterator;

		HashTable()
		{}

		//显示编译器去生产默认构造函数
		//HashTable() = default;

		//ht(ht1)
		HashTable(const Self& ht)
		{
			_table.resize(ht._table.size());

			for (size_t i = 0; i < ht._table.size(); ++i)
			{
				Node* cur = ht._table[i];
				while (cur)
				{
					Node* copy = new Node(cur->_data);
					copy->_next = _table[i];
					_table[i] = copy;
					cur = cur->_next;
				}
			}
			_n = ht._n;
		}

		Self& operator=(Self ht)
		{
			_table.swap(ht._table);
			swap(_n, ht._n);
			return *this;
		}

		~HashTable()
		{

		}

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

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

		iterator find(const K& key)
		{
			if (_table.size() == 0)
				return end();
			HashFunc hf;
			KeyOfT kot;
			size_t index = hf(key) % _table.size();
			Node* cur = _table[index];
			while (cur)
			{
				if (kot(cur->_data) == key)
					return iterator(cur, this);
				else
				{
					cur = cur->_next;
				}
			}
			return end();
		}

		bool erase(const K& key)
		{
			if (_table.empty())
			{
				return false;
			}

			HashFunc hf;
			KeyOfT kot;
			size_t index = hf(key) % _table.size();
			Node* cur = _table[index];
			Node* prev = nullptr;
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					if (prev == nullptr)//头删
					{
						_table[index] = cur->_next;
					}
					else//中间删除
					{
						prev->_next = cur->_next;
					}
					delete cur;
					--_n;
					return true;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}//end of whlie
			return false;
		}

		pair<iterator, bool> insert(const T& data)
		{
			KeyOfT kot;
			iterator ret = find(kot(data));
			if (ret != end())
			{
				return make_pair(ret, false);
			}
			HashFunc hf;
			if (_n == _table.size())
			{
				size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
				vector<Node*> newTable;
				newTable.resize(newSize);

				for (size_t i = 0; i < _table.size(); ++i)
				{
					Node* cur = _table[i];
					while (cur)
					{
						Node* next = cur->_next;
						size_t index = hf(kot(cur->_data)) % newSize;
						cur->_next = newTable[index];
						newTable[index] = cur;
						cur = next;
					}
				}
				swap(_table, newTable);
			}
			size_t index = hf(kot(data)) % _table.size();
			Node* newNode = new Node(data);
			newNode->_next = _table[index];
			_table[index] = newNode;

			++_n;
			return make_pair(iterator(newNode, this), true);
		}

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

}

3.2 封装unordered_map

#pragma once
#include "HashTable.h"
using namespace LinkHash;

namespace ns_um
{
	template<class K, class V, class HashFunc = Hash<K>>
	class unordered_map
	{
	private:
		struct KeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename HashTable<K, pair<K, V>, KeyOfT, HashFunc>::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)
		{
			auto ret = _ht.insert(make_pair(key, V()));
			return ret.first->second;
		}

	private:
		HashTable<K, pair<K, V>, KeyOfT, HashFunc> _ht;
	};
}

3.2 封装unordered_set

#pragma once
#include "HashTable.h"
using namespace LinkHash;

namespace ns_us
{
	template<class K, class HashFunc = Hash<K>>
	class unordered_set
	{
	private:
		struct KeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};

	public:
		typedef typename HashTable<K, K, KeyOfT, HashFunc>::iterator iterator;

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

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

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

	private:
		LinkHash::HashTable<K, K, KeyOfT, HashFunc> _ht;
	};
}
小唐学渣
关注
  • 15
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 15
    评论
专栏目录
LeetCode:LeetCode 刷题笔记(C++, Python 实现)
04-12
从列表末尾删除第N个节点 链表 20 有效括号 堆叠与排队 21岁 合并两个排序列表 链表 22 产生括号 回溯＆DFS和BFS 23 合并k个排序列表 链表 24 成对交换节点 链表 25 Reverse_Nodes_in_k组 链表 26 从排序...
C++ unordered_map实现方案，与hash冲突解决办法
yptsqc的博客
07-17 9390
unordered_map有点类似c++11之前的非标准库hash_map, c++11后， 加入了unordered_map， 可就用来代替之前的hash_map。 今天来看看unordered_map的底层实现。 END
C++数据结构：哈希 -- unordered系列容器、哈希表的结构以及如何通过闭散列的方法解决哈希冲突
weixin_43908419的博客
05-14 1713
本文介绍了unordered系列的容器以及哈希的结构，并讲解了如何通过闭散列的方法解决哈希冲突然后进行了模拟实现
C++ 哈希表及unordered_set + unordered_map容器
冰果滴的博客
09-14 2955
前言：unordered_set和unordered_map是C++11中新增加的两个关联式容器，使用方式与set和map基本相同，但是unordered_set和unordered_map的底层是哈希表，而set和map的底层是红黑树。并且unordered_set不能排序；unordered_set和unordered_map是单向迭代器；效率要高一下，时间复杂度为O(1)。
C++的unordered_map使用
sinat_31608641的博客
07-08 1910
一、原理介绍 unordered_map: unordered_map内部实现了一个哈希表（也叫散列表），通过把关键码值映射到Hash表中一个位置来访问记录。但其元素的排列顺序是无序的。哈希表最大的优点，就是把数据的存储和查找消耗的时间大大降低，查找的时间复杂度可达到O(1)，其在海量数据处理中有着广泛应用；而代价仅仅是消耗比较多的内存。然而在当前可利用内存越来越多的情况下，用空间换时间的做法是值得的。另外，编码比较容易也是它的特点之一。 其基本原理是：使用一个下标范围比较大的数组来存储元素。可以设计一
深入剖析 std::unordered_map 的实现原理之 Hash冲突、退化
loOK后端
02-27 7227
本次来讲解下c++中 std::unordered_map的设计原理。 std::unordered_map里面has-a哈希表，它提供的的各个方法基本都是由hashtable封装实现，因此在下文使用hashtable来描述std::unordered_map。 // gnu 实现 template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
C++ STL开发技术导引(第5章)
09-25
第19章　queue队列容器　270 19.1　queue技术原理　270 19.2　queue应用基础　271 19.3　本章小结　274 第20章　priority_queue优先队列容器　275 20.1　priority_queue技术原理　275 20.2　priority_queue应用基础...
C++ STL 开发技术导引(第6章)
09-25
第19章　queue队列容器　270 19.1　queue技术原理　270 19.2　queue应用基础　271 19.3　本章小结　274 第20章　priority_queue优先队列容器　275 20.1　priority_queue技术原理　275 20.2　priority_queue应用基础...
C++ STL开发技术导引(第3章)
09-25
第19章　queue队列容器　270 19.1　queue技术原理　270 19.2　queue应用基础　271 19.3　本章小结　274 第20章　priority_queue优先队列容器　275 20.1　priority_queue技术原理　275 20.2　priority_queue应用基础...
leetcode1004-Leetcode:Leetcode问题-2021
07-01
从列表末尾删除第 N 个节点 :orange_circle: 20. 有效括号 :green_circle: 字符串、堆栈 ✓ ✓ 21. 合并两个排序列表 :green_circle: 链表 ✓ 26. 从有序数组中删除重复项 :green_circle: 数组，两个指针 ✓ 27. ...
【C++】哈希——unordered系列容器&哈希概念&哈希冲突
weixin_63249832的博客
05-24 811
unordered系列容器的使用，哈希概念，哈希冲突，哈希冲突的解决
C++实现哈希表 HashMap冲突链式解决
霖林烟雨
05-31 8129
简述： 考虑到有大量数据的情况，所以使用Hash表 使用泛型实现 TypeA 是Key的类型，TypeB 是value的类型 1. 主要函数 1). TypeB Put(HashNode 函数用来加入一个新的MapNode 2). TypeB Delete(const TypeA& key) 用来删除一个键值为key的节点 3). TypeB GetValue(const
map/unordered_map基础用法
weixin_36670529的博客
04-28 3418
map是STL里重要容器之一。 它的特性总结来讲就是：所有元素都会根据元素的键值key自动排序（也可根据自定义的仿函数进行自定义排序），其中的每个元素都是<key,value>的键值对，map中不允许有键值相同的元素， 因此map中元素的键值key不能修改，但是可以通过key修改与其对应的value。如果一定要修改与value对应的键值key，可将已存在的key删除掉，然后重新插入。 定义原型： 它作用应用场景可用作①字典 ②统计次数 相关操作 （1）插入操作 方式有...
力扣-350题 两个数组的交集II（C++）- 两种解法 unordered_map元素增删改查规整
qq_40467670的博客
07-16 142
题目链接：https://leetcode-cn.com/problems/intersection-of-two-arrays-ii/ 题目如下： class Solution { public: void inter(vector<int>& nums1,vector<int>& nums2,vector<int>& result){//nums1长度大于等于nums2 unordered_map<int,int
unordered_map/hash等相关整理。
qq_26133677的博客
04-21 509
unordered_map/hash等相关整理。 由于是学习笔记后的整理，所以这篇文章比较粗略。后续改进。
突破编程_C++_C++11新特性（unordered_map）
最新发布
突破编程
03-18 1035
C++11 新特性：unordered_map
unordered_map自定义数据结构
ahundredmile的博客
07-24 390
C++ std::unordered_map自定义数据结构 {自定义哈希方法 + 自定义比较方法}
C++11标准中的unordered_map()函数
att0206的博客
08-16 1979
参考：cplusplus的reference 最近在刷Leetcode和《剑指Offer》算法题，其中就遇到了许多C++11新特性的内容出现，比如unordered_map()函数，这是一个无序的哈希表函数，...
std::unordered_map主键为结构体
哎哟哟也爱技术
04-12 1396
在C++中，当我们将某个数据或对象保存为二进制进行存储或发送时，经常使用std::vector<char>，与new char[LEN]，使用std::vector<char>相比有什么好处呢？ std::vector<char>作为一个容易，对字符数组进行了封装，提供了丰富的接口，不需要手动进行内存的释放，std::vector<char>的对象出了作用域，会进行自动释放内存。 今天讲一讲，使用std::vector<char>的对象进行二进
C++实现sha1哈希填充
06-13
SHA-1是一种哈希算法，它...接下来，我们使用SHA1_Update函数将要哈希的字符串添加到上下文中，并使用SHA1_Final函数将哈希值存储到hash数组中。最后，我们使用std::stringstream将哈希值转换为十六进制字符串并返回。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小唐学渣

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

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

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

打赏作者

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

抵扣说明：

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

余额充值