异曲同工之妙，哈希封装的set与map（包含测试代码）

最新推荐文章于 2024-09-25 11:53:45 发布
最新推荐文章于 2024-09-25 11:53:45 发布
阅读量768 收藏 22
点赞数 25
分类专栏： c++ 文章标签： 哈希算法 算法 c++ 数据结构 散列表 开源
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/creative_mind/article/details/141230819
版权

引子：我们在之前用红黑树来进行封装set与map二大容器，c++11引入了unordered_map，与unordered_set的新容器，这个底层就是哈希表！

告知：布隆过滤器，我只学了原理，下次，我再来代码呈现，我们也要进入c++的学习了，下次，更精彩（抱拳）

话不多说我们直接上代码，请君自行测试

Hash.h底层部分

#pragma once
#pragma once
#include<iostream>
#include<string>
#include<vector>

using namespace std;

//key要求有转整形的作用
	template<class K>
	class Hash_to_int
	{
	public:
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};

	//对于string类的转换--特化
	template<>
	class Hash_to_int<string>
	{
	public:
		//仿函数
		size_t operator()(const string& key)
		{
			size_t numi = 0;
			for (auto e : key)
			{
				numi *= 131;
				numi += e;
			}
			return numi;
		}
	};




namespace My_hash
{
	//悬挂的节点
	template<class T>
	struct HashNode
	{
		T _data;
		HashNode<T>* _next;

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


	//前置声明
	template<class K, class T, class KeyofT,class hash= Hash_to_int<K>>
	class HashTable;

	//迭代器
	template<class K, class T, class Ptr, class Ref,class KeyofT ,class hash = Hash_to_int<K>>
	class Hash_iterator
	{
	public:

		typedef HashNode<T> Node;
		typedef Hash_iterator<K, T, Ptr, Ref,KeyofT,hash> Self;

		Node* _node;
		const HashTable<K, T,KeyofT,hash>* _table;

		Hash_iterator(Node*node, const HashTable<K, T, KeyofT, hash>* table)
			:_node(node)
			,_table(table)
		{}

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

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

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

		Self& operator++()
		{
			if (_node->_next)
			{
				_node = _node->_next;
			}
			else
			{
				KeyofT kot;
				hash to_int;
				size_t numi = to_int(kot(_node->_data)) % _table->_tables.size();
				++numi;
				while (numi < _table->_tables.size())
				{
					if (_table->_tables[numi])
					{
						break;
					}
					++numi;
				}
				if (numi == _table->_tables.size())
					 _node = nullptr;
				else
					 _node = _table->_tables[numi];
			}
			return *this;
		}
	};

	 
	template<class K, class T,class KeyofT,class hash>
	class HashTable
	{
	public:
		typedef HashNode<T> Node;
		template<class K, class T, class Ptr, class Ref, class KeyofT,class hash >
		friend class Hash_iterator;

		//普通迭代器
		typedef Hash_iterator<K, T, T*, T&,KeyofT,hash> Iterator;
		//const迭代器
		typedef Hash_iterator<K, T, const T*, const T&,KeyofT,hash> Const_Iterator;
	public:
		Iterator End()
		{
			return Iterator(nullptr, this);
		}

		Iterator Begin()
		{
			size_t numi = 0;
			for (; numi < _tables.capacity(); ++numi)
			{
				if (_tables[numi])
					break;
			}
			if (numi < _tables.capacity())
				return Iterator(_tables[numi], this);
			else
				return Iterator(nullptr, this);
		}

		Const_Iterator End() const
		{
			return Const_Iterator(nullptr, this);
		}


		Const_Iterator Begin() const
		{
			if (_number == 0)
				return End();

			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				if (cur)
				{
					return Const_Iterator(cur, this);
				}
			}

			return End();
		}

		HashTable()
			:_number(0)
		{
			_tables.resize(10, nullptr);
		}

		~HashTable()
		{
			// 依次把每个桶释放
			for (size_t i = 0; i < _tables.size(); i++)
			{
				Node* cur = _tables[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				_tables[i] = nullptr;
			}
		}


		//查找
		Iterator Find(const K& key)
		{
			KeyofT kot;
			hash to_int;
			size_t hashi = to_int(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return Iterator(cur, this);
				}

				cur = cur->_next;
			}

			return End();
		}

		//插入
		pair<Iterator,bool> insert(const T&data)
		{
			KeyofT kot;
			Iterator it = Find(kot(data));
			if (it != End())
			{
				return make_pair(it,false);
			}


			hash to_int;
			size_t numi = to_int(kot(data)) % _tables.size();

			//负载因子为1时进行扩容
			//即size与数据点相等
			if (_number == _tables.size())
			{
				vector<Node*> newTable(_tables.size() * 2);
				//挪动数据
				for (size_t i = 0; i < _tables.size(); i++)
				{
					Node* current = _tables[i];
					while (current)
					{
						Node* next = current->_next;
						size_t numii = to_int(kot(current->_data)) % newTable.size();

						// 头插到新表
						current->_next = newTable[numii];
						newTable[numii] = current;
						current = next;
					}

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

			//进行头插
			Node* cmp = new Node(data);
			cmp->_next = _tables[numi];
			_tables[numi] = cmp;
			_number++;
			return make_pair(Iterator(cmp,this),true);
		}

		//删除
		bool Erase(const K& key)
		{
			hash to_int;
			//找出位置
			size_t numi = to_int(key) % _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[numi];
			while (cur)
			{
				if (cur->_data == key)
				{
					if (prev == nullptr)
					{
						_tables[numi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					_number--;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}
		
		// 新增遍历函数
		void Traverse()
		{
			for (size_t i = 0; i < _tables.size(); i++)
			{
				KeyofT kot;
				Node* current = _tables[i];
				while (current)
				{
					cout << kot(current->_data)<< "  "<< endl;
					current = current->_next;
				}
			}
		}

	private:
		vector<Node*> _tables;
		size_t _number;
	};

}

unordered_Map部分

#pragma once
#include"Hash.h"
//#include<unordered_map>
namespace My_Map
{

    template<class K,class V,class hash=Hash_to_int<K>>
    class unordered_Map
    {
    public:
        class M_KeyofT
        {
        public:
            const K& operator()(const pair<K, V>& kv)
            {
                return kv.first;
            }

        };

        typedef typename My_hash::HashTable<K, pair<const K, V>, M_KeyofT, hash>::Iterator iterator;
        typedef typename My_hash::HashTable<K, pair<const K, V>, M_KeyofT, hash>::Const_Iterator const_iterator;

        iterator begin()
        {
            return _cmp.Begin();
        }

        iterator end()
        {
            return _cmp.End();
        }

        const_iterator begin() const
        {
            return  _cmp.Begin();
        }

        const_iterator end() const
        {
            return  _cmp.End();
        }

        pair<iterator,bool> insert(const pair<K,V>& kv)
        {
            return _cmp.insert(kv);
        }


        //如果找到就是有重复值，find功能
        //没有则为insert功能
        V& operator[](const K& key)
        {
            pair<iterator, bool> ret = _cmp.insert(make_pair(key, V()));

            return ret.first->second;
        }

        iterator Find(const K& key)
        {
            return _cmp.Find(key);
        }

        bool Erase(const K& key)
        {
            return _cmp.Erase(key);
        }

    private:
        My_hash::HashTable<K, pair<const K,V>, M_KeyofT, hash>_cmp;
    };
    
    void test_map()
    {
        unordered_Map<string, string> dict;
        dict.insert(make_pair("sort", "排序"));
        dict.insert({ "left", "左边" });
        dict.insert({ "right", "右边" });

        dict["left"] = "左边，剩余";
        dict["insert"] = "插入";
        dict["string"];


        for (auto e : dict)
        {
            cout << e.first << ":" << e.second << endl;
        }
    }
}

unordered_Set部分

#pragma once
#include"Hash.h"


namespace My_Set
{
    template<class K, class hash = Hash_to_int<K>>
    class unordered_Set
    {
    public:
        class S_keyofT
        {
        public:
            const K& operator()(const K& key)
            {
                return key;
            }
        };

        typedef typename My_hash::HashTable<K, const K, S_keyofT, hash>::Iterator iterator;
        typedef typename My_hash::HashTable<K, const K, S_keyofT, hash>::Const_Iterator const_iterator;
        iterator begin()
        {
            return _cmp.Begin();
        }

        iterator end()
        {
            return _cmp.End();
        }

        const_iterator begin() const
        {
            return  _cmp.Begin();
        }

        const_iterator end() const
        {
            return  _cmp.End();
        }

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

        iterator Find(const K& key)
        {
            return _cmp.Find(key);
        }

        bool Erase(const K& key)
        {
            return _cmp.Erase(key);
        }

    private:
        My_hash::HashTable<K, const K, S_keyofT, hash>_cmp;
    };
    
    void Print(const unordered_Set<int>& s)
    {
        unordered_Set<int>::const_iterator it = s.begin();
        while (it != s.end())
        {
            cout << *it << " ";
            ++it;
        }
        cout << endl;
    }

    struct Date
    {
        int _year;
        int _month;
        int _day;

        bool operator==(const Date& d) const
        {
            return _year == d._year
                && _month == d._month
                && _day == d._day;
        }
    };

    struct HashDate
    {
        size_t operator()(const Date& key)
        {
            // 112
            // 121
            return (key._year * 31 + key._month) * 31 + key._day;
        }
    };

    void test_set()
    {
        unordered_Set<int> s;
        int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14, 3,3,15 };
        for (auto e : a)
        {
            s.insert(e);
        }

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


        unordered_Set<Date, HashDate> us;
        us.insert({ 2024, 7, 25 });
        us.insert({ 2024, 7, 26 });
        for (auto e : us)
        {
            cout << e._year << " " << e._month << " " << e._day << endl;
        }
    }
}

测试结果：

大家有疑问，直接在评论区问我，我们一起进步！

creative_mind
关注
专栏目录
架构师技能5：如何做code review 代码简洁之道
黄规速博客:学如逆水行舟，不进则退
01-15 2293
前言 CodeReview的目的是提升代码质量，尽早发现潜在缺陷与BUG，降低修复成本，同时促进团队内部知识共享，帮助更多人更好地理解系统。 如何做好code review，可以参考谷歌code review 指南。原文地址:https://google.github.io/eng-practices/review/reviewe code review从大的方面来说： 1、业务层面：业务逻辑是否正确等相关内容。例如 1）数据库字段的设计是否合理。 2）业务流程是否按............
Leetcode快速入门之开宗明义: 掌握概念和学习语法
热门推荐
herosunly的博客
06-09 1万+
1. 为什么要学习基本概念 2. 学习编程语法 2.1 为什么要学习C++和Java 2.2 C++基本语法 2.2.1 程序基本结构 2.2.2 静态数组 2.2.3 动态数组vector 2.2.4 字符串string 2.2.5 结构体struct 2.2.6 链表ListNode 2.2.7 哈希表unordered_map 2.2.8 集合unordered_set 2.2.9 队列queue 2.2.10 栈stack 2.2.11 优先队列 2.2.12 其他常用API 2.2.13 C++常
C++ 哈希底层原理
2301_79964905的博客
08-12 715
哈希是一种建立映射的思想，我们尝试用的数据结构是哈希表 ，又称「散列表」，其通过建立键 key 与值 value 之间的映射，实现高效的元素查询。具 体而言，我们向哈希表输入一个键 key ，则可以在 𝑂(1) 时间内获取对应的值 value。早期的C++的STL中没有hash表，在C++11中，STL又提供了4个 unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是 其底层结构不同。其中unordered_set就是一种哈希表。关于C++函数的查询可以点击下面链接。
【C++】哈希表/哈希桶
KL4180的博客
07-04 880
【C++】哈希表/哈希桶
C++:unordered_map/unordered_set
RNGWGzZs的博客
07-30 500
准确来说unordered系列关联式容器,是在C++11出来的。因为在C++98中引入了以红黑树为底层的map/set,但是当树的高度足够高,节点足够多时,查询的效率是不理想的。unordered_multimap和unordered_multiset和multimap/multiset异曲同工。因为其底层本身就是实现的是单链表。unorderd系列底层封装的哈希结构;"只有我,守着安静的沙漠。(一)unorderd系列容器;(一)unorderd系列容器;本篇就到此为止,谢谢你的阅读。...
JavaSE进阶之（十）Map 子接口之 ConcurrentHashMap
qq_50994235的博客
10-29 1093
Map 子接口之 ConcurrentHashMap
哈希表1--初识哈希表、哈希冲突的解决方案、哈希函数、各种类型的数据如何生成哈希值
qq_43507104的博客
08-20 951
一，前言 前说TreeMap添加，删除，搜索的时间复杂度都是 O(logn),效率算是比较高的了。但是TreeMap有约束条件 1). Key必须具备可比较性 2).元素分布是有序的 但是在实际开发中我们的Key不具有可比较性，Map中的元素分布也不需要顺序。不考虑顺序，不考虑Key的可比较性，Map有更好的实现方案，平均复杂度可以达到O(1)级别。就是使用哈希表来实现Map。 二，初识哈希表 哈希表处理数据的流程如下 我们拥有如下数据 哈希表添加、搜索、删除的步骤都是类似的 1).利用哈希函数生成Key对
手撕Java和Go的Map
qq_41354702的博客
08-29 605
文章目录Java的MapHashMap底层用到数组+链表？工作原理？get()方法的实现过程？重写equals方法需同时重写hashCode方法？jdk1.8链表基础上超过8换成红黑树进一步加速查找速度扩容操作？通过resize()方法HASH方法？链地址法为什么数组长度要保证为2的幂次方呢？Object作为K应该怎么办呢？初始化长度？与HashTable关键不同点？Go的Mapmapmap的结构？key的定位写入的流程扩容 Java会比Go详细点，因为我先学的Java，最近学的Go。有一点比较明显的，Go
学习java集合Collection、Map,看这篇文章就够了
qq_40949759的博客
06-27 282
一、Collection 集合内部存储的基本类型的数据都会被自动装箱 集合的顶级接口，是Iterable的儿子 public interface Collection<E> extends Iterable<E> 1. Iterable java.lang包中 public interface Iterable<T> { Iterator<T> iterator(); default void forEach(Consumer<? s
哈希map以及set的封装
04-05
在这个场景中，我们讨论的是C++中的哈希表实现，即`哈希map`和`哈希set`的封装，它们是STL（标准模板库）的一部分，由`unordered_map`和`unordered_set`两个容器来表示。 首先，我们来看`哈希map`。`std::unordered...
代码随想录：哈希表的应用与优化
09-17
主要内容概述：文章全面介绍了哈希表的基本概念、常见的哈希结构（如哈希表、Set、Map）、典型应用场景，以及详细的哈希法运用实例，对比不同数据结构解决实际问题的效果，包括数组作为哈希表、Set和Map在实际问题中...
红黑树封装map&&set源代码
06-01
封装红黑树的Map和Set源代码通常会包括以下关键部分： 1. **节点定义**：首先，需要定义红黑树的节点结构，包括键、值、颜色属性、左子节点和右子节点。例如： ```java class Node { Key key; Value value; ...
java中 Set与Map排序输出到Writer详解及实例
08-31
_java中Set与Map排序输出到Writer详解及实例_ Java中，Set和Map都是常用的集合类型，但是它们的输出顺序并不是按key的顺序排列的。这篇文章将介绍如何将Java中的Set和Map排序输出到Writer，并提供了相关的代码实现...
189. 轮转数组（C++）
weixin_45813121的博客
09-25 437
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
Python实现Phong着色模型算法
qq_42568323的博客
09-24 1319
通过本文的介绍，我们详细阐述了Phong着色模型的基本原理，并使用Python实现了相关的算法。通过定义向量、光源、材质和着色器等类，我们可以灵活地计算光照和着色效果，为更复杂的三维图形渲染打下基础。Phong着色模型是计算机图形学中的经典光照模型，尽管随着技术的发展，出现了更复杂的光照模型（如Blinn-Phong、物理基础渲染等），但其简洁明了的特点仍然使其在许多应用中得以广泛使用。希望通过本次学习，读者能够深入理解Phong着色模型，并能够在实际项目中应用该算法。
完全二叉树和堆排序
最新发布
2301_80412275的博客
09-25 506
在满足第一个条件的前提下，最后一层的节点从左到右填充，没有空隙。
算法训练营打卡Day14
Zoe_igxgx的博客
09-25 232
题目1.226.翻转二叉树题目2.101. 对称二叉树。
时间序列分析算法
qq_58353992的博客
09-24 911
通信领域：网络流量预测、服务器负载预测等。
关于哈希set和哈希map：
06-02
哈希set和哈希map都是基于哈希表实现的数据结构，不同之处在于哈希set只存储键，而哈希map存储键值对。这意味着，在哈希set中，每个键都必须是唯一的，而在哈希map中，每个键可以对应一个值。 哈希set和哈希map的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值