基于哈希的unordered_系列容器实现

最新推荐文章于 2023-09-23 12:47:57 发布
最新推荐文章于 2023-09-23 12:47:57 发布
阅读量392 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43780350/article/details/100164891
版权

文章目录

关联式容器：哈希结构

哈希表的改造

Common.hpp

const int PRIMECOUNT = 28;
const size_t primeList[PRIMECOUNT] =
{
	53ul, 97ul, 193ul, 389ul, 769ul,
	1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
	49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
	1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
	50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
	1610612741ul, 3221225473ul, 4294967291ul
};
size_t GetNextPrime(size_t prime)
{
	size_t i = 0;
	for (; i < PRIMECOUNT; ++i)
	{
		if (primeList[i] > prime)
			return primeList[i];
	}

	return primeList[i];//PRIMECOUNT-1
}

HashBucket.hpp

#pragma once

//开散列：一个链表的集合---产生相同哈希地址的元素放到同一个链表中
#include <string>
#include <vector>
#include <assert.h>
#include "Common.hpp"
template<class T>
struct HashNode
{
	HashNode(const T&data = T())
		:_pNext(nullptr)
		, _data(data)
	{}
	HashNode<T>* _pNext;
	T _data;
};
template<class T>
struct DefD2INIT
{
	const T& operator()(const T& data)
	{
		return data;
	}
};
struct Str2INT
{
	size_t operator()(const string& s)
	{
		return (size_t)s.c_str();//可以学习博客中的字符串哈希算法
	}
};
template<class T, class K, class KOFV, class DTOINT = DefD2INIT<T>>
class hashbucket;
template<class T, class K, class KOFV,class DTOINT>
struct hashbucketIterator
{
	typedef HashNode<T> Node;
	typedef hashbucketIterator<T, K, KOFV, DTOINT> Self;
public:
	hashbucketIterator(Node* pNode = nullptr, hashbucket<T, K, KOFV, DTOINT>* ht=nullptr)
		:_pNode(pNode)
		, _pHt(ht)
	{}
	T& operator*()
	{
		return _pNode->_data;
	}
	T* operator->()
	{
		return  &(operator*());
	}
	Self& operator++()
	{
		Next();
		return *this;
	}
	Self operator++(int)
	{
		Self temp(*this);
		Next();
		return temp;
	}
	bool operator==(const Self& s)const
	{
		return _pNode == s._pNode;
	}
	bool operator!=(const Self& s)const
	{
		return _pNode != s._pNode;
	}
	void Next()
	{
		if (_pNode->_pNext)
			_pNode = _pNode->_pNext;
		else
		{
			//获取当前桶号
			size_t bucketNo = _pHt->HashFunc(KOFV()(_pNode->_data)) + 1;
			//依次往后获取非空桶
			for (; bucketNo < _pHt->_table.capacity(); ++bucketNo)
			{
				if (_pHt->_table[bucketNo])
				{
					_pNode = _pHt->_table[bucketNo];
					return;
				}
			}
			_pNode = nullptr;
		}
	}
	Node* _pNode;
	hashbucket<T, K, KOFV, DTOINT>* _pHt;
};


//T代表节点中的元素
//unordered_map:键值对
//unordered_set:key
template<class T, class K, class KOFV, class DTOINT>
class hashbucket
{
	friend hashbucketIterator<T, K, KOFV, DTOINT>;
	typedef HashNode<T> Node;
	typedef hashbucket<T, K, KOFV, DTOINT> Self;
public:
	typedef hashbucketIterator<T, K, KOFV, DTOINT> iterator;
public:
	hashbucket(size_t capacity = 10)
		:_table(GetNextPrime(capacity))
		, _size(0)
	{}
	~hashbucket()
	{
		Clear();
	}
	iterator begin()
	{
		//找第一个非空桶
		for (size_t i = 0; i < _table.capacity(); ++i)
		{
			if (_table[i])
				return iterator(_table[i], this);
		}
		return end();
	}
	iterator end()
	{
		return iterator(nullptr, this);
	}
	pair<iterator, bool> Insert(const T& data)
	{
		_CheckCapacity();
		//通过哈希函数计算哈希桶号
		size_t bucketNo = HashFunc(KOFV()(data));
		Node* pCur = _table[bucketNo];
		while (pCur)
		{
			if (data == pCur->_data)
				return make_pair(iterator(pCur,this), false);
			pCur = pCur->_pNext;
		}
		pCur = new Node(data);
		pCur->_pNext = _table[bucketNo];
		_table[bucketNo] = pCur;
		_size++;
		return make_pair(iterator(pCur,this), true);
	}
	size_t Erase(const K& key)
	{
		size_t bucketNo = HashFunc(key);
		Node* pCur = _table[bucketNo];
		Node* pPre = nullptr;
		while (pCur)
		{
			if (key == KOFV()(pCur->_data))
			{
				//可以删除
				if (pCur == _table[bucketNo])
					_table[bucketNo] = pCur->_pNext;
				else
					pPre->_pNext = pCur->_pNext;
				delete pCur;
				--_size;
				return 1;
			}
			else
			{
				pPre = pCur;
				pCur = pCur->_pNext;
			}
		}
		return 0;
	}
	iterator Find(const K& key)
	{
		size_t bucketNo = HashFunc(key);
		Node* pCur = _table[bucketNo];
		while (pCur)
		{
			if (KOFV()(pCur->_data) == key)
				return iterator(pCur, this);
			pCur = pCur->_pNext;
		}
		return end();
	}
	size_t Size()const
	{
		return _size;
	}
	bool Empty()const
	{
		return 0 == _size;
	}
	void Clear()
	{
		for (size_t bucketNo = 0; bucketNo < _table.capacity(); bucketNo++)
		{
			Node* pCur = _table[bucketNo];
			while (pCur)
			{
				_table[bucketNo] = pCur->_pNext;
				delete pCur;
				pCur = _table[bucketNo];
			}
		}
		_size = 0;
	}
	void Swap(Self& ht)
	{
		_table.swap(ht._table);
		swap(_size, ht._size);
	}
	void PrintfHashBucket()
	{
		for (size_t i = 0; i < _table.capacity(); ++i)
		{
			Node* pCur = _table[i];
			cout << "table[" << i << "]:";
			while (pCur)
			{
				cout << pCur->_data << "--->";
				pCur = pCur->_pNext;
			}
			cout << "NULL" << endl;
		}
	}
	size_t BucketCount()const
	{
		return _table.capacity();
	}
	size_t BucketSize(size_t bucketNo)const
	{
		assert(bucketNo < BucketCount());
		Node* pCur = _table[bucketNo];
		size_t szcount = 0;
		while (pCur)
		{
			szcount++;
			pCur = pCur->_pNext;
		}
		return szcount;
	}
	size_t Bucket(const K& key)
	{
		return HashFunc(key);
	}
private:
	size_t HashFunc(const K& key)
	{
		//T：可以是任意类型，可能不是整型，string怎么办？
		return DTOINT()(key) % _table.capacity(); //怎么保证每次扩容是两次关系且（%的是素数），有待百度
	}
	void _CheckCapacity()
	{
		if (_size == _table.capacity())
		{
			Self newHT(GetNextPrime(_table.capacity()));
			//将旧哈希桶中的节点往新哈希桶中搬移
			for (size_t i = 0; i < _table.capacity(); ++i)
			{
				Node* pCur = _table[i];
				//将i号桶中的所有节点搬移到新哈希桶中
				while (pCur)
				{
					//将pCur节点从_table的第i号桶移除掉
					_table[i] = pCur->_pNext;
					//将pCur节点插入到新哈希桶中
					size_t bucketNo = newHT.HashFunc(KOFV()(pCur->_data));
					//采用头插法
					pCur->_pNext = newHT._table[bucketNo];
					newHT._table[bucketNo] = pCur;
					newHT._size++;
					_size--;
					pCur = _table[i];
				}
			}
			this->Swap(newHT);
		}
	}
private:
	vector<Node*> _table;//存每一个链表的首地址
	size_t _size;
};

C++11 unordered_系列

1. unordered_map

<key,value>—>key必须唯一

1.1代码实现

unordered_map.hpp

#pragma once

#include "HashBucket.hpp"
namespace bite
{
	template<class K,class V,class KTOINT=DefD2INIT<K>>
	class unordered_map
	{
		typedef pair<K, V> ValueType;
		struct KOFV
		{
			const K& operator()(const ValueType& data)
			{
				return data.first;
			}
		};
		typedef hashbucket<ValueType,K, KOFV, KTOINT> HT;
		typename typedef HT::iterator iterator;
	public:
		unordered_map()
			:_ht()
		{}
		//iterator
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		//capacity
		bool empty()const
		{
			return _ht.Empty();
		}     
		size_t size()const
		{
			return _ht.Size();
		}
		//access
		V& operator[](const K& key)
		{
			return (*_ht.Insert(make_pair(key,V())).first).second;
		}
		//Modifiers
		pair<iterator, bool> insert(const ValueType& data)
		{
			return _ht.Insert(data);
 		}
		size_t erase(const K& key)
		{
			return _ht.Erase(key);
		}
		void clear()
		{
			_ht.Clear();
		}
		void swap(unordered_map<K,V,KTOINT>& m)
		{
			_ht.Swap(m._ht);
		}
		size_t bucket_count()const
		{
			return _ht.BucketCount();
		}
		size_t bucket_size(size_t bucketNo)
		{
			return _ht.BucketSize(bucketNo);
		}
		size_t bucket(const K& key)
		{
			return _ht.Bucket(key); 
		}
		iterator find(const K& key)
		{
			return _ht.Find(key);
		}
	private:
		HT _ht;
	};
}
void  TestUnorderedMap()//测试
{
 	bite::unordered_map<int, int> m;
 	m.insert(make_pair(1, 1));
	m.insert(make_pair(10, 10));
	m.insert(make_pair(21, 21));
	cout << m.size() << endl;
 	for (auto e:m)
 		cout << e.first << "--->" << e.second << endl;
 	cout << endl;
	m.erase(10);
	if (m.find(10) == m.end())
		cout << "10 erase is ok" << endl;
	else
		cout << "10 erase if no" << endl;
	m.clear();
	cout << m.size() << endl;
}
1.2map和unordered_map的区别
  1. mao中key—>关于key有序的序列
  2. 查找的时间复杂度：map—>O(logN) unordered_mao：O(1)
  3. 应用场景：
  4. 底层结构：map—>红黑树 unordered_map：哈希桶
  5. 存储方式不同：

    根据key的hash值判断元素是否相同，即unordered_map内部元素是无序的，
    而map中的元素是按照二叉搜索树存储，进行中序遍历会得到有序遍历。
    6.插入方式不同、查找方式不同、删除方式不同、接口不同

1.3优缺点以及适用处
map

优点：
有序性，这是map结构最大的优点，其元素的有序性在很多应用中都会简化很多的操作
红黑树，内部实现一个红黑书使得map的很多操作在lgnlgn的时间复杂度下就可以实现，因此效率非常的高
缺点：
空间占用率高，因为map内部实现了红黑树，虽然提高了运行效率，但是因为每一个节点都需要额外保存父节点，孩子节点以及红/黑性质，使得每一个节点都占用大量的空间
适用处，对于那些有顺序要求的问题，用map会更高效一些

unordered_map

优点：
因为内部实现了哈希表，因此其查找速度非常的快
缺点：
哈希表的建立比较耗费时间
适用处，对于查找问题，unordered_map会更加高效一些，因此遇到查找问题，常会考虑一下用unordered_map

2. unordered_set

key—>key必须唯一

2.1代码实现

unordered_set

#pragma once
#include "HashBucket.hpp"
namespace bite
{
	template<class K, class KTOINT = DefD2INIT<K>>
	class unordered_set
	{
		typedef K ValueType;
		struct KOFV
		{
			const K& operator()(const ValueType& data)
			{
				return data;
			}
		};
		typedef hashbucket<ValueType, K, KOFV, KTOINT> HT;
		typename typedef HT::iterator iterator;
	public:
		unordered_set()
			:_ht()
		{}
		//iterator
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		//capacity
		bool empty()
		{
			return _ht.Empty();
		}
		size_t size()const
		{
			return _ht.Size();
		}
	
		//Modifiers
		pair<iterator, bool> insert(const ValueType& data)
		{
			return _ht.Insert(data);
		}
		size_t erase(const K& key)
		{
			return _ht.Erase(key);
		}
		void clear()
		{
			_ht.Clear();
		}
		void swap(unordered_set<K, KTOINT>& m)
		{
			_ht.Swap(m._ht);
		}
		size_t bucket_count()const
		{
			return _ht.BucketCount();
		}
		size_t bucket_size(size_t bucketNo)
		{
			return _ht.BucketSize(bucketNo);
		}
		size_t bucket(const K& key)
		{
			return _ht.Bucket(key);
		}
		iterator find(const K& key)
		{
			return _ht.Find(key);
		}
	private:
		HT _ht;
	};
}
void  TestUnorderedSet()//测试
{
	bite::unordered_set<int> m;
	m.insert(1);
	m.insert(10);
	m.insert(21);
	cout << m.size() << endl;
	for (auto e : m)
	cout << e<< endl;
 	cout << endl;
	m.erase(10);
	if (m.find(10) == m.end())
		cout << "10 erase is ok" << endl;
	else
		cout << "10 erase if no" << endl;
	m.clear();
	cout << m.size() << endl;
}

3. unordered_multimap

<key,value>—>key可以重复

4. unordered_multiset

key—>key可以重复

爱马拉松的东宫高兴
关注
专栏目录
C++容器之基于哈希表实现的unordered_set
yyl80的博客
05-23 631
1. 基本概念 unordered_set是无序数据集，也就是没有以特别的顺序存储数据。这个是基于哈希表实现的数据容器。哈希表本质上是一个数组，与常见的数组不同的是，哈希表中存放的值是键值对。键值对就是可以根据一个键值获取对应的一个值。而对于键值，百度百科的解释是“键值（key）是windows中注册表中的概念。键值位于注册表结构链末端，和文件系统的文件类似，包含当前计算机及应用程序执行时使用的实际配置信息和数据。键值包含几种数据类型，以适应不同环境的使用需求。”通过一个键值获取对应的一个值，这个有点类似高
STL总结之unordered_map/unordered_multimap
YangLei253的博客
07-30 2750
介绍 unordered_map 是一个封装哈希表的无序容器。容器中每个元素都是 key/value，每个 key 仅可出现一次。 unordered_multimap 是一个封装哈希表的无序容器。容器中每个元素都是 key/value，每个 key 可重复出现。 unordered_map 和 unordered_multimap 均定义于头文件 <unordered_map> 中，...
Java集合中基于hash的容器
YinKailin的专栏
09-12 701
Java集合中基于hash的容器
【STL】哈希表 {unordered系列容器的介绍和使用；模拟实现unordered_set和unordered_map}
芥末虾的博客
09-23 484
【STL】哈希表 {unordered系列容器的介绍和使用；模拟实现unordered_set和unordered_map}
哈希容器的使用
weixin_33955681的博客
09-17 170
为什么80%的码农都做不了架构师？>>> ...
unordered_map 简介
柔水终成雕刀
03-11 3万+
头文件 在使用unordered_map时，需要引入头文件： #include < unordered_map > 内部实现 unordered_map内部实现了一个哈希表（也叫散列表，通过把关键码值映射到Hash表中一个位置来访问记录，查找的时间复杂度可达到O(1)，其在海量数据处理中有着广泛应用）。因此，其元素的排列顺序是无序的。 与map对比 map 优点： 有序性，这是map结构最大的优点，其元素的有序性在很多应用中都会简化很多的操作； 红黑树，内部实现一个红黑树使得m
【C++STL】unordered_map
ETO的博客
07-20 4031
unordered_map 前言 如果想对unordered_map有一个全面了解的读者可以参考：unordered_map - C++ Reference 正文 下面直接说怎样实现： #include<tr1/unordered_map>//在unordered...
C++中的哈希容器unordered_map使用示例
09-03
在C++编程语言中，`unordered_map`是一个非常重要的数据结构，它属于C++标准库中的哈希容器，提供了一种高效的方式来存储键值对。`unordered_map`在C++0x标准（即C++11）中被正式引入，之前在TR1和一些第三方库如...
unordered_map_unordered_map_
09-29
由于它基于哈希表的实现，查找、插入和删除操作通常具有O(1)的时间复杂度，这使得它在处理大量数据时具有很高的性能。`unordered_map`的关键特性包括： 1. 键与值的关联：每个元素都是一个键值对，其中键是唯一的，...
C++11 unordered_map与map（插入,遍历，Find）效率对比。
08-24
而`std::unordered_map`则是基于哈希表实现的无序关联容器，它的插入操作通常更快，因为它不需要维持元素顺序，只需找到合适的哈希桶位置即可。 **插入操作**： - `std::map`：插入操作通常需要O(log n)的时间...
map/unordered_map原理和使用整理
自由理想的足迹
04-15 6万+
map的内部实现是二叉平衡树(红黑树)；hash_map内部是一个hash_table一般是由一个大vector，vector元素节点可挂接链表来解决冲突，来实现. hash_map其插入过程是： 得到key通过hash函数得到hash值得到桶号(一般都为hash值对桶数求模)存放key和value在桶内。 其取值过程是: 得到key通过hash函数得到hash值得
unordered_map的介绍及使用
gp1330782530的博客
05-28 7014
unordered_map的介绍及使用 1、unordered_map的介绍 1、unordered_map是存储<key, value>键值对的关联式容器，其允许通过key快速的索引到与其对应的value 2、unordered_map中，键值通常用于惟一的标识元素，而映射值是一个对象，其内容与此键关联，键和映射的类型可以不同 3、在内部，unordered_map没有对<key, value>进行排序，unordered_map将相同哈希值的键值对放在对应的桶中 4、unord
关联容器：unordered_map详细介绍（附可运行代码）
weixin_30448685的博客
04-01 3267
介绍 1 特性 2 Hashtable和bucket 模版 1 迭代器 功能函数 1 构造函数 12示例代码 2 容量操作 21 size 22 empty 3 元素操作 31 find 32 insert 33 at 34 erase 35 clear 36 swap 37 示例代码 4 迭代器和bucket操作 41 begin 42 e...
c++中unordered_map的用法
m0_38038327的博客
02-20 2451
unordered_map是c++-11新加的一个标准容器，它提供了一对一的关系，并且在查找速度上能达到O (1)的速度。本文总结了它的一些基本用法，以供以后参考。 １．unordered_map的构造函数 unordered_map<string,int> mapstring; unordered_map<int,string> mapint; unordere...
C++中的unordered_map用法详解
热门推荐
zou_albert的博客
06-27 19万+
1 简介 unordered_map是一个将key和value关联起来的容器，它可以高效的根据单个key值查找对应的value。 key值应该是唯一的，key和value的数据类型可以不相同。 unordered_map存储元素时是没有顺序的，只是根据key的哈希值，将元素存在指定位置，所以根据key查找单个value时非常高效，平均可以在常数时间内完成。 unordered_map查询单个key的时候效率比map高，但是要查询某一范围内的key值时比map效率低。 可以使用[]操作符来访问key值对应的
一篇文章总结完哈希表2种散列，及位图和布隆过滤器具体应用
藏宝大厦
07-23 329
Hash表学习目录1. 无序系列关联式容器1. unordered_map2. unordered_set2. 哈希表1. 哈希函数2. 哈希冲突3. 模拟实现1. 模板参数列表2. 迭代器，哈希表的实现3. 无序的map实现4. 无序的 set 实现4. 应用1. 位图2. 布隆过滤器3. 哈希切割 1. 无序系列关联式容器 1. unordered_map 是存储<key，value>键值对的关联式容器，其允许通过keys快速索引到其对应的value。 通过key访问单个元素的效率要比m.
map和unordered_map的差别和使用
weixin_34405557的博客
10-30 6518
map和unordered_map的差别还不知道或者搞不清unordered_map和map是什么的，请见：http://blog.csdn.net/billcyj/article/details/78065438 需要引入的头文件不同map: #include < map >unordered_map: #include < unordered_map > 内部实现机...
unordered_map使用详解
weixin_45745854的博客
02-04 4万+
STL：unordered_map使用笔记 参考网址： cpluscplus unordered_map与map的区别（CSDN） 1.概述 unordered_map的模板定义如下： template < class Key, // unordered_map::key_type class T, // unordered_map:
C++STL中基于哈希的关联式容器
weixin_42067873的博客
08-16 504
一、hash_map原理 hash_map基于hash table（哈希表）。 哈希表最大的优点，就是把数据的存储和查找消耗的时间大大降低，几乎可以看成是常数时间；而代价仅仅是消耗比较多的内存。然而在当前可利用内存越来越多的情况下，用空间换时间的做法是值得的。另外，编码比较容易也是它的特点之一。 其基本原理是：使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数，也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标，hash值）相对应，于是用这个数组单元来存储这个元素；也可以简
c++哈希表unordered_set unordered_map
最新发布
10-12
unordered_set和unordered_map都是C++ STL中的容器，它们都是基于哈希表实现的。unordered_set是一个集合容器，其中的元素是唯一的，而unordered_map是一个关联容器，其中的元素是键值对，每个键只能出现一次。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值