unordered_map set的模拟实现

最新推荐文章于 2024-09-20 12:59:10 发布
最新推荐文章于 2024-09-20 12:59:10 发布
阅读量106 收藏
点赞数
文章标签： 哈希表 哈希
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w1724556613/article/details/117605731
版权
本文详细介绍了使用C++实现哈希表的开散列处理冲突的方法，强调了迭代器在处理链表遍历中的关键作用。讨论了如何通过哈希函数对不同类型的键进行转换，特别是对字符串类型的特化处理。此外，还探讨了迭代器的设计，包括处理桶间切换的策略，以及在C++11中通过节点前后置指针优化迭代器的方法。文章还提到了哈希表的扩容策略，使用素数表降低冲突，并展示了如何在map和set中实例化模板。
摘要由CSDN通过智能技术生成

设计容器时，哈希注重的是如何处理哈希冲突，显然，开散列的处理方式要优于闭散列，因此使用开散列处理哈希冲突，模拟实现的本质是对迭代器如何处理，因为其他的接口都是很好完成的，但是迭代器如何形成遍历的方式呢？

在封装迭代器前，我们先思考一个问题，如何进行类型的不同调整，因为底层是用除留余数法进行映射的，但是除了整形，还有什么能取余呢，因此需要对不同的类型进行不同的转换，我们只是模拟实现，因此处理最多使用的string类，使用模板的特化，对string类进行特殊处理，这样将其转换成对应的整形，这里也要使用一下仿函数来进行特化的处理。

迭代器的封装一样，封装的是节点，所以遍历的方式是和链表一样，但是最主要的问题是，一个桶遍历完了后，如何切换到下一个桶~

我们给出的方案是，将哈希表也封装在迭代器中，然后使用哈希表来定位桶。但这样也无疑使结构变得复杂，因此c++11中使用的方式是，将节点增加两个指针，一个是前置，一个后置，让插入顺序为这个链表的顺序，因此同样的节点有着两个顺序的链接方式，依此来处理迭代器，但是这样在插入和删除方向要复杂一些。

当然任何的事物都有其优缺点，但是在实现的方向上，我们主要学习其实现的思想，更多的是这种高维度的泛型技术，使用一个哈希表，同时满足两种实现，高维度的泛型技术是必修课。对于迭代器的处理我们可以想不出来，但是对于泛型的高维度使用却是必须掌握的。

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


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

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

template<class K, class T, class KOfT, class Hash>
class HashTable;


template <class K,class T,class KOfT,class Hash>
struct __Hashiterator
{
	typedef  __Hashiterator<K, T, KOfT, Hash> Self;
	typedef HashTable<K, T, KOfT, Hash> HT;
	typedef HashNode<T> Node;
	Node* _node;
	HT* _pht;

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

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

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

	bool operator!=(Node* node)
	{
		return _node != node;
	}

	bool operator==(Node* node)
	{
		return _node == node;
	}

	Self operator++()
	{
		if (_node->_next)
		{
			_node = _node->_next;
		}
		else
		{
			KOfT koft;
			size_t index = _pht->HashFunc(koft(_node->_data)) % 
							_pht->_tables.size();
			index++;

			while (index < _pht->_tables.size())
			{
				if (_pht->_tables[index])
				{
					_node = _pht->_tables[index];
					return *this;
				}
			}
			_node = nullptr;
		}

		return *this;
	}

};


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

template <>
struct _Hash <string>
{
	size_t operator() (const string& s)
	{
		size_t hash = 0;
		for (int i = 0; i < s.size(); i++)
		{
			hash *= 131;
			hash += s[i];
		}
	}
};

template<class K, class T, class KOfT ,class Hash>
class HashTable
{
	friend struct  __Hashiterator<K, T, KOfT, Hash>;
	typedef HashNode<T> Node;
	typedef __Hashiterator<K, T, KOfT, Hash> iterator;
public:
	iterator begin()
	{
		for (int i = 0; i < _tables.size(); i++)
		{
			if (_tables[i])
			{
				return iterator(_tables[i], this);
			}
		}

		return end();
	}

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


	~HashTable()
	{
		clear();
	}

	void clear()
	{
		for (int 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 HashFunc(const K& key)
	{
		Hash hash;
		return hash(key);
	}
	size_t GetPrime(size_t num)
	{
		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
		};


		for (size_t i = 0; i < PRIMECOUNT; i++)
		{
			if (primeList[i] > num)
			{
				return primeList[i];
			}
		}

		return primeList[28];
	}
	


	pair<iterator,bool> insert(const T& d)
	{
		KOfT koft;

		if (_num == _tables.size())
		{
			vector<Node*> newtables;
			size_t newsize = GetPrime(_tables.size());
			//size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
			newtables.resize(newsize);

			for (int i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];

				while (cur)
				{
					Node* next = cur->_next;
					int index = HashFunc(koft(cur->_data)) % newtables.size();
					cur->_next = newtables[index];
					newtables[index] = cur;

					cur = next;
				}

				_tables[i] == nullptr;
			}
			_tables.swap(newtables);
		}




		size_t index = HashFunc(koft(d)) % _tables.size();

		Node* cur = _tables[index];

		while (cur)
		{
			if (koft(cur->_data) == koft(d))
			{
				return make_pair(iterator(cur, this), false);
			}
			else
			{
				cur = cur->_next;
			}
		}

		Node* newnode = new Node(d);
		newnode->_next = _tables[index];
		_tables[index] = newnode;

		_num++;

		return make_pair(iterator(newnode,this),true);

	}

	Node* find(const K& key)
	{
		KOfT koft;
		size_t index = key % _tables.size();
		Node* cur = _tables[index];

		while (cur)
		{
			if (koft(cur->_data) == key)
			{
				return cur;
			}
			else
			{
				cur = cur->_next;
			}
		}

		return nullptr;
	}

	bool erase(const K& key)
	{
		KOfT koft;
		size_t index = key % _tables.size();
		Node* cur = _tables[index];
		Node* prev = nullptr;

		while (cur)
		{
			if (koft(cur->_data) == key)
			{
				if (prev == nullptr)
				{
					_tables[index] = cur->_next;
				}
				else
				{
					prev->_next = cur->_next;
				}
				delete cur;
				_num--;
				return true;
			}
			else
			{
				prev = cur;
				cur = cur->_next;
			}
		}


		return false;
	}

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

set

#pragma once
#include "hash.h"


namespace whc
{
	template <class K,class Hash = _Hash<K>>
	class unordered_set
	{
		struct SetKOfT
		{
			const K& operator() (const K& key)
			{
				return key;
			}

		};
	public:
		typedef typename HashTable<K, K, SetKOfT, Hash>::iterator iterator;

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

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


		pair<iterator,bool> insert(const K& key)
		{
			return _ht.insert(key);
		}
	private:
		HashTable<K, K, SetKOfT,Hash> _ht;
	};
}

map

#pragma once
#include <iostream>
using namespace std;
#include "hash.h"


namespace whc
{
	template <class K,class V,class Hash = _Hash<K>>
	class unordered_map
	{
		struct MapKOfT
		{
			const K& key operator() (const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename HashTable<K, K, SetKOfT, Hash>::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)
		{
			pair<iterator, bool> ret = _ht.insert(make_pair(key, V()));

			return ret.first->second;
		}

	private:
		HashTable<K, pair<K, V>, MapKOfT,Hash> _ht;
	};
}

以上还有两点细节需要说明：
第一是对于扩容的方式，因为研究表明素数的哈希冲突较为小，所以使用一个素数表来进行扩容。
第二是在map和set中还未进行模板的实例化，因此使用typedef的时候，要使用后面实例化的模板，就得在前面用typename进行声明，来告诉编译器，后面会实例化的。

w1724556613
关注
unordered_map和unordered_set的模拟实现
01-20
unordered_map和unordered_set的模拟实现 （一）哈希表的特性及概念 定义： 哈希表（Hash table，也叫散列表），是根据关键字值（key,value）直接进行访问的数据结构。也就是说，它通过把关键字映射到表中一个位置来...
c++ unordered_set详细操作
热门推荐
qq_40286920的博客
05-12 3万+
一、使用前提 引入头文件： #include <unordered_set> 1 二、unordered_set是什么 unordered_set 容器，可直译为“无序 set 容器”。即 unordered_set 容器和 set 容器很像，唯一的区别就在于 s...
C++容器——集合（unordered_set）
shouhu010的博客
03-28 5655
C++ 容器 unordered_set 初始化 元素访问 元素操作
【C++进阶】map和set的使用
最新发布
2301_78022459的博客
09-20 1371
【C++进阶】map和set的使用
C++基础知识4：unordered_set
qq_35702489的博客
12-11 3754
简单的介绍一下unordered在不同地方使用的作用，在全局，在函数，在类里面的使用，以及相关应用举例
C++ —— unordered_set、unordered_map的介绍及使用
weixin_66905164的博客
06-19 2620
unordered_multimap容器与unordered_map容器的底层数据结构是一样的，都是哈希表，其次，它们所提供的成员函数的接口都是基本一致的，这里就不再列举了，这两种容器唯一的区别就是，unordered_multimap容器允许键值冗余，即unordered_multimap容器当中存储的键值对的key值是可以重复的。在内部，unordered_set中的元素没有按照任何特定的顺序排序，为了能在常数范围内找到指定的3.key，unordered_set将相同哈希值的键值放在相同的桶中。
【C++】unordered_set 容器的最全解析（什么是unordered_set?unordered_set的常用接口有那些？）
weixin_45031801的博客
08-31 3061
【unordered_set】是STL中的容器之一，不同于普通容器，它的查找速度极快，常用来存储各种经常被检索的数据，因为容器的底层是【哈希表】。除此之外，还可以借助其特殊的性质，解决部分难题。
C++开源项目：模拟实现小型STL
11-27
7. **哈希表（Hash Tables）**：`stl_hashtable.h`可能是哈希表的实现，如`unordered_set`和`unordered_map`，它们提供常数时间的查找和插入性能。 8. **位集（Bitset）**：`bitset`是一个可以将整数数组映射为位...
STL-Manual.rar_stl chm
09-23
- **unordered_set**和**unordered_multiset**：哈希表实现，提供快速查找，但不保证顺序。 - **unordered_map**和**unordered_multimap**：哈希表实现的键值对容器。 2. 迭代器： - 迭代器是STL中的重要概念，...
STL-70个算法.rar_C++_stl 练习
09-23
STL提供了一些核心的数据结构，如vector（动态数组）、list（双向链表）、deque（双端队列）、set（红黑树实现的集合）、map（红黑树实现的键值对映射）和unordered_set/unordered_map（哈希表实现的集合和映射）。...
c++用vector实现HashSet
08-16
虽然C++标准库中没有直接提供HashSet类，但我们可以利用其他容器，如`std::unordered_set`来实现类似的功能。不过，在这个场景中，我们将探讨如何使用`std::vector`来模拟HashSet的行为。 `std::vector`是C++标准库...
【 C++ 】unordered_map和unordered_set的介绍和使用
bit_zyx的博客
09-10 7292
目录 1、unordered系列关联式容器 2、unordered_map unordered_map的介绍 unordered_map的构造方式 unordered_map的函数接口说明 unordered_multimap 3、unordered_set unordered_set的介绍 unordered_set的构造方式 unordered_set的函数接口说明
unordered_set基本用法
努力的小白马
03-27 2万+
unordered_setUnodered Set 无序集(unorder sets)是一种不按特定顺序存储唯一元素的容器，允许根据元素的值快速检索单个元素。 在unordered_set中，元素的值同时也是唯一标识它的键。键是不可变的，因此，unordered_set中的元素在容器中不能被修改，但是它们可以被插入和删除。 在内部，unordered_set中的元素并不按照任何特定的顺序排序，而是根据它们的散列值组织到桶中，从而允许根据它们的值直接快速访问单个元素(平均时间复杂度为常数)。 与set容
C++11:关联式容器：unordered_set
qq_59535638的博客
06-08 1959
unoredered_set特性，常用接口的使用
unordered_set
m0_51548759的博客
01-04 854
c++ STL unordered_set
C++进阶--unordered_set、unordered_map的介绍和使用
sushang的博客
01-15 4000
1.unordered_set是不按特定顺序存储键值的关联式容器，其允许通过键值快速的索引到对应的元素。2.在unordered_set中，元素的值同时也是唯一的标识它的key。3.在内部，unordered_set中的元素没有按照任何特定的顺序排序，为了能在常数范围内找到指定的key，unordered_set将相同哈希值的键值放在相同的桶中。4.unordered_set容器通过key访问单个元素要比set快，但它通常在遍历元素子集的范围迭代方面效率较低。5.它的迭代器至少是前向迭代器。
C++总结(7)：STL无序容器之unordered_set、unordered_map、unordered_multiset、unordered_multimap详解
主要分享硬件、嵌入式软件部分知识
11-06 2万+
前两节介绍了STL中的和，本节来介绍一下无序容器。无序容器与关联容器类似，但是关联容器是顺序排序的，而无序容器实现了未排序(哈希)的数据结构。
unordered_set的理解与使用
qq_44423388的博客
10-07 3162
unordered_set 是含有 Key 类型唯一对象集合的关联容器。搜索、插入和移除拥有平均常数时间复杂度。 在内部，元素并不以任何特别顺序排序，而是组织进桶中。元素被放进哪个桶完全依赖其值的哈希。这允许对单独元素的快速访问，因为哈希一旦确定，就准确指代元素被放入的桶。 不可修改容器元素（即使通过非 const 迭代器），因为修改可能更改元素的哈希，并破坏容器。
unordered_set总结
2201_75772333的博客
05-10 1495
是C++标准库中的一个容器，它可以存储不重复的元素集合。这个容器的特点是内部元素没有特定的顺序，因此查找、插入和删除操作的平均时间复杂度是O(1)。是基于哈希表实现的，所以在使用时需要提供一个哈希函数和相等函数。在的内部，数据通常存储在哈希表中。哈希表由桶组成，每个桶存储具有相同哈希值的元素。然而，这些实现细节是在类定义中隐藏的，用户不需要关心这些细节。您可以使用提供的成员函数来操作和查询容器的状态，例如插入、删除、查找元素，以及查询容器的大小、负载因子等。
unordered_map和unordered_set的模拟实
10-07
它们的模拟实现基于哈希表的数据结构。哈希表通过将关键字映射到表中的一个位置来进行访问，从而实现快速的查找和插入操作。 unordered_map是存储键值对的关联式容器，它通过key快速索引到与其对应的value。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值