略谈set与map的pair封装与进入哈希

最新推荐文章于 2024-08-09 20:36:57 发布
最新推荐文章于 2024-08-09 20:36:57 发布
阅读量715 收藏 10
点赞数 20
分类专栏： c++ 文章标签： 哈希算法 算法 c++ 经验分享 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/creative_mind/article/details/141053322
版权

引子：之前我们讲了红黑树的自实现，与小小的接口实现，那set与map的pair封装是如何实现的呢？，今天我们来一探究竟，而且我们也要进入新章节--哈希

对于operator--()的封装：

注意：牢记思考的方向始终是中序

示意图：

stl代码实现：

  void decrement()
  {
    if (node->color == __rb_tree_red &&
        node->parent->parent == node)
      node = node->right;
    else if (node->left != 0) {
      base_ptr y = node->left;
      while (y->right != 0)
        y = y->right;
      node = y;
    }
    else {
      base_ptr y = node->parent;
      while (node == y->left) {
        node = y;
        y = y->parent;
      }
      node = y;
    }
  }
};

自实现：我们在传的时候要传一下_root,因为我们不是通过以上stl中hearer的方式

迭代器部分更改：

Node* _root;

RBTreeIterator(Node*node,Node*root)
	:_node(node)
	,_root(root)
{}
self& operator--()
{
	if (_node == nullptr) 
	{
		//找最右节点
		Node* rightMost = _root;
		while (rightMost && rightMost->_right)
		{
			rightMost = rightMost->_right;
		}

		_node = rightMost;
	}
	else if (_node->_left)
	{
		Node* rightMost = _node->_left;
		while (rightMost->_right)
		{
			rightMost = rightMost->_right;
		}

		_node = rightMost;
	}
	else
	{
		Node* cur = _node;
		Node* parent = cur->_parent;
		while (parent && cur == parent->_left)
		{
			cur = parent;
			parent = cur->_parent;
		}

		_node = parent;

	}

	return *this;
}

对于set的insert封装：

//插入
pair<iterator,bool>insert(const T& data)
{
	//空树新增节点，也是红黑树
	Node* root = _root;
	if (root == nullptr)
	{
		root = new Node(data);
		_root = root;
		_root->_col = BLACK;
		return make_pair(iterator(_root, _root), true);
	}

    //红黑树大逻辑
	K_of_T kot;
	Node* cur = _root;
	Node* parent = nullptr;

	//要先找到，插入位置
	while (cur)
	{
		if (kot(data) < kot(cur->_Data))
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (kot(data) > kot(cur->_Data))
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
		   return make_pair(iterator(cur, _root), false);
		}
	}

	cur = new Node(data);
	// 新增节点。颜色红色给红色
	cur->_col = RED;
	Node* newNode = cur;
	if (kot(parent->_Data) < kot(data))
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	cur->_parent = parent;

	//更改颜色
	//现在cur为新增节点
	while (parent && parent->_col==RED)
	{
		Node* grandfather = parent->_parent;

		//找出叔叔节点
		if (parent == grandfather->_left)
		{
			Node* uncle = grandfather->_right;
			//情况一
			if (uncle && uncle->_col == RED)
			{
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandfather->_col = RED;
				cur = grandfather;
				parent = cur->_parent;
			}
			else
			{
				//情况二
				//    g
				//  p   u
				//c
				if (parent->_left == cur)
				{
					RotateR(grandfather);
					grandfather->_col = RED;
					parent->_col = BLACK;
				}
				else
				{
					//情况三
					//    g
					//  p   u
					//    c
					// 
					//双旋
					RotateL(parent);
					RotateR(grandfather);

					//注意cur与parent调了一下位置
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;
			}
		}
		else
		{
			Node* uncle = grandfather->_left;
			//情况一
			if (uncle && uncle->_col == RED)
			{
				parent->_col = BLACK;
				uncle->_col = BLACK;
				grandfather->_col = RED;
				cur = grandfather;
				parent = cur->_parent;
			}
			else
			{ 
				//情况二
				//    g
				//  u   p
				//        c
				if (cur == parent->_right)
				{
					RotateL(grandfather);
					grandfather->_col = RED;
					parent->_col = BLACK;
				}
				//情况三
				//    g
				//  u   p
				//    c    
				else
				{
					RotateR(parent);
					RotateL(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;
			}
		}
	}

	//确保根节点为黑的
	_root->_col = BLACK;
	return make_pair(iterator(newNode, _root), true);
}

对于：map的话，只要将k对应的vaule输出就行！，注意调用的时候也要改为pair<iterator,bool>！

什么是哈希？

一，哈希是一种数学函数，它接受一个输入（或“消息”），然后返回一个通常更小的固定大小的输出，这个输出称为“哈希值”或“哈希码”。

二，哈希也是一种思想：映射：哈希思想通过哈希函数将任意长度的数据映射到固定长度的哈希值。这个映射过程是单向的，即从数据到哈希值是容易的，但从哈希值回溯到原始数据几乎是不可能的。快速性：哈希函数的设计旨在快速计算，以便在大数据集中实现高效的数据访问。均匀分布：理想情况下，哈希函数应该能够将输入数据均匀地分布在哈希值空间中，以减少冲突并提高查找效率。

哈希的应用：

哈希思想在数据库索引、密码存储、信息检索、数据同步、数字签名、区块链技术等多个领域都有广泛的应用。通过哈希，可以有效地管理和访问大量数据，同时保证数据的安全性和完整性。

由哈希来的哈希表（unordered）

一，背景：

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

以下是unordered_set与set的区别图，我们可以更加看到底层结构为哈希表的优势！

对于调试性能，大家可以通过以下代码进行测试：

#include<unordered_set>
#include<iostream>
#include<set>

using namespace std;



int test_set2()
{
	const size_t N = 10000000;

	unordered_set<int> us;
	set<int> s;

	vector<int> v;
	v.reserve(N);
	srand(time(0));
	for (size_t i = 0; i < N; ++i)
	{
		//v.push_back(rand()); // N比较大时，重复值比较多
		//v.push_back(rand()+i); // 重复值相对少
		v.push_back(i); // 没有重复，有序
	}

	size_t begin1 = clock();
	for (auto e : v)
	{
		s.insert(e);
	}
	size_t end1 = clock();
	cout << "set insert:" << end1 - begin1 << endl;

	size_t begin2 = clock();
	for (auto e : v)
	{
		us.insert(e);
	}
	size_t end2 = clock();
	cout << "unordered_set insert:" << end2 - begin2 << endl;

	int m1 = 0;
	size_t begin3 = clock();
	for (auto e : v)
	{
		auto ret = s.find(e);
		if (ret != s.end())
		{
			++m1;
		}
	}
	size_t end3 = clock();
	cout << "set find:" << end3 - begin3 << "->" << m1 << endl;

	int m2 = 0;
	size_t begin4 = clock();
	for (auto e : v)
	{
		auto ret = us.find(e);
		if (ret != us.end())
		{
			++m2;
		}
	}
	size_t end4 = clock();
	cout << "unorered_set find:" << end4 - begin4 << "->" << m2 << endl;

	cout << "插入数据个数：" << s.size() << endl;
	cout << "插入数据个数：" << us.size() << endl << endl;

	size_t begin5 = clock();
	for (auto e : v)
	{
		s.erase(e);
	}
	size_t end5 = clock();
	cout << "set erase:" << end5 - begin5 << endl;

	size_t begin6 = clock();
	for (auto e : v)
	{
		us.erase(e);
	}
	size_t end6 = clock();
	cout << "unordered_set erase:" << end6 - begin6 << endl << endl;

	return 0;
}


int main()
{

	test_set2();

	return 0;
}

可以有以下的结果：只展示一种

哈希函数

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

哈希函数设计原则：

哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值 域必须在0到m-1之间

哈希函数计算出来的地址能均匀分布在整个空间中

哈希函数应该比较简单

常见的哈希函数包括以下几种类型：(最常用的，用颜色标出了)

直接定址法：使用关键字本身作为哈希地址，例如年龄作为关键字时，年龄值直接作为哈希地址 

数字分析法：选择数字的某些部分作为哈希地址，避免使用重复可能性大的数字前几位 

平方取中法：取关键字平方后的中间几位作为哈希地址 

折叠法：将关键字分割成位数相同的几部分，然后取这几部分的叠加和作为哈希地址 

除留余数法：使用关键字除以一个不大于哈希表大小的数后的余数作为哈希地址，公式为 H(key) = key%p (p ≤ m) ;

随机数法：使用随机函数作为哈希地址，适用于关键字长度不等的情况 

加法哈希：通过将字符串中每个字符的ASCII值累加得到哈希值 

位运算Hash：利用位运算（如移位和异或）混合输入元素，例如旋转Hash 

乘法Hash：使用乘法的不相关性，例如使用乘数31的String类的hashCode()方法 

除法Hash：虽然不常用，但除法也具有不相关性，可以用于哈希函数 

查表Hash：如CRC系列算法，通过查找预设的表来实现快速哈希 

混合哈希算法：结合以上各种方式，例如MD5、Tiger等，它们通常用于需要高安全性的场合 

哈希冲突解决

哈希冲突

哈希冲突，也称为哈希碰撞，是指两个不同的输入值通过哈希函数计算后得到相同的哈希值。由于哈希函数的输出长度是固定的，而输入数据可以是无限的，理论上讲，任何哈希函数都可能发生冲突.

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

一，什么是闭散列

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

1.1，线性探测（需要枚举3种状态）

  1. 计算哈希值：首先，使用哈希函数计算键（key）的哈希值，确定它在哈希表中的理论位置。

  2. 检查冲突：如果该位置已被占用（即发生冲突），则按照固定间隔（通常是1）移动到下一个位置。

  3. 探测序列：继续线性地探测下一个位置，直到找到一个空闲位置。

  4. 插入元素：一旦找到空闲位置，将元素插入到该位置。

  5. 处理表满：如果探测到表的末尾仍未找到空闲位置，则循环回到表的开头继续探测。

  6. 查找元素：在查找元素时，也需要从哈希值对应的位置开始，按照相同的探测序列查找，直到找到目标元素或遇到一个空闲位置（表示元素不存在）。

  7. 删除元素：删除元素时，不能简单地将位置置为空，因为这会打断查找其他元素的探测序列。通常使用一个特殊的标记（如“已删除”标记）来代替真正的空位。

1.2，二次探测（需要枚举3种状态）

  1. 计算哈希值：首先，使用哈希函数计算键的哈希值，确定它在哈希表中的理论位置。

  2. 发生冲突：如果该位置已被占用，计算下一个探测位置，公式为： 探测位置=(原始位置)+i^2 其中 i 是探测的第几次尝试（i=1,2,3,…）

  3. 探测序列：探测位置是原始哈希值加上 i^2 的结果，这样探测的间隔会随着 i 的增加而增加（1, 4, 9, 16, ...）。

  4. 插入元素：当找到一个空闲位置时，将元素插入到该位置。

  5. 循环探测：如果探测到表尾，继续从表头开始探测，直到找到空闲位置。

  6. 查找元素：查找时，也需要按照相同的探测序列进行查找，直到找到目标元素或确定元素不存在。

  7. 删除元素：与线性探测类似，不能简单地将位置置为空，而是使用一个特殊的标记来表示该位置已被删除。

其他：平衡因子：

哈希的平衡因子，也称为荷载因子（Load Factor），是衡量哈希表性能的一个重要参数。它定义为哈希表中已存储元素的数量与哈希表的总槽位数（即哈希表的大小）之比。荷载因子用以下公式表示

荷载因子=已存储元素的数量​/哈希表的大小

荷载因子反映了哈希表的填充程度，对哈希表的性能有直接影响

二，什么是开散列，就是说

开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地 址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链 接起来，各链表的头结点存储在哈希表中。

下节，我将详细讲解哈希表，已经自实现！，希望帮到大家！

creative_mind
关注
  • 20
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
哈希map以及set的封装
04-05
在这个场景中，我们讨论的是C++中的哈希表实现，即`哈希map`和`哈希set`的封装，它们是STL（标准模板库）的一部分，由`unordered_map`和`unordered_set`两个容器来表示。 首先，我们来看`哈希map`。`std::unordered...
java中 Set与Map排序输出到Writer详解及实例
08-31
_java中Set与Map排序输出到Writer详解及实例_ Java中，Set和Map都是常用的集合类型，但是它们的输出顺序并不是按key的顺序排列的。这篇文章将介绍如何将Java中的Set和Map排序输出到Writer，并提供了相关的代码实现...
【C++】哈希封装map与set
m0_74246469的博客
04-20 1020
unordered_map和unordered_set的封装实现
哈希封装unordered_map和unordered_set
小白成长之路
04-19 909
看哈希如何封装unordered_map和unordered_set
【C++】使用哈希表封装unordered_map与unordered_set
weixin_69380220的博客
07-28 818
unordered_map与unordered_set的封装
哈希表的改造 | 封装unordered_set与unordered_map
2301_78131481的博客
08-04 208
与map、set的封装类似，unordered系列的底层本质上也是复用，通过对哈希表的改造，再分别套上一层unordered_map和unordered_set的“壳子”，以达到“一表二用”的目的。unordered系列的底层哈希表是用结构实现的。
C++进阶之map与set
cls的博客
05-23 2423
stl中将数据结构叫做容器。 容器分为 序列式容器：vector/list... 就类似线性表 关联史容器：map/set.. 数据之间有强烈的关联性，底层是搜索树 栈和队列是适配器 set底层就是搜索树。 void test_set1() { //排序＋去重 set<int> s; s.insert(3); s.insert(1); s.insert(8); s.insert(2); s.insert(5); s.insert(5); s.insert(5)
C++数据结构 —— 哈希表、unordered_map/set封装
weixin_59913110的博客
03-17 1443
顺序结构以及平衡二叉搜索树结构中，在查找一个元素时需要经过比较。顺序查找时间复杂度为O(N)，平衡二叉搜索树查找时间复杂度为O(log_2N)。理想的搜索方法便是不经过任何比较，通过常数次的操作从表中得到搜索的元素。如果构造一种存储结构，如果某种函数使元素的存储位置与它存储的元素之间形成一种映射关系，那么在查找中可以通过该函数很快找到搜索元素。该方式称为哈希(散列)方法，哈希方法使用的转换函数称为哈希函数， 构造出来的数据结构称为哈希表。
哈希桶封装unordered_map、unordered_set
mastershooter的博客
06-08 871
我们将由下列的哈希桶来模拟封装STL库中的unordered_map和unordered_set注意：为了实现封装unordered_map和unordered_set，我们需要对下列源码进行优化。
java map与set的区别_java中Map,List与Set的区别
weixin_42592399的博客
02-12 712
一、集合简介1.Java中的集合分为三类：1.1Set(集)1.2 List(列表)1.3 Map(映射)2. 集合解释List：相当于可以自动扩展的数组set：没有重复的数组TreeSet，TreeList，Tree**：自动排序的数组3. 集合的实现几乎所有的集合都是基于数组实现的。因为集合是对数组做的封装，所以，数组永远比任何一个结合要快。4. 集合的优点任何一个集合，比数组提供的功能要多...
哈希表+封装map和set
欢迎来到梨+萍的博客，不准备看点啥学习嘛。。。
04-19 173
介绍unordered_map，unordered_set,对比底层红黑树和哈希表的性能；介绍了哈希表两种实现方式，开散列和闭散列。哈希表封装map和set
Java中的Set、List、Map的用法与区别介绍
09-02
在Java编程语言中，集合框架是处理对象的重要工具，其中包括三种主要类型的集合：Set、List和Map。它们各自具有不同的特点和用法，适合不同场景的需求。 首先，Set集合是不包含重复元素的集合，它按照特定的规则...
set,list,map区别与联系
11-29
### set、list、map的区别与联系 #### 一、概述 在Java编程语言中，`set`、`list`和`map`是非常重要的数据结构，它们分别代表了不同的集合类型，各自有着独特的特性与用途。 - **List**：有序集合，可以包含重复...
ES6中Set和Map数据结构，Map与其它数据结构互相转换操作实例详解
12-02
Map数据结构则与Set不同，它存储键值对，且键可以是任何类型，而不仅仅是对象。Map也有自己的构造函数，如下： ```javascript let map = new Map(); ``` Map的操作方法包括`set()`, `get()`, `has()`, `delete()`, `...
day 9 回溯算法
m0_73924943的博客
08-08 196
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
嵌入式初学-C语言-十五
MaBaB的博客
08-05 636
函数：实现一定功能的，独立的代码模块，我们的函数一定是先定义后使用使用函数的优势可以通过函数提供功能给别人使用，当然我们也可以使用别人提供的函数，减少代码量借助函数可以减少重复性代码。实现结构化（模块化）程序设计思想结构化程序设计思想：将大型的任务功能，划分为相互独立的小型的任务模块来设计3.函数是c语言程序的基本组成单元：C语言程序是由一个（必然是main函数）或多个函数组成。语法：返回类型 函数名(形参列表) -- 函数头 | 函数首部。
[算法] 第二集 二叉树中的深度搜索
最新发布
2301_80017277的博客
08-09 401
一、（DFS，全称为 Depth First Traversal），是我们树或者图这样的数据结构中常⽤的⼀种遍历算法。这个算法会尽可能深的搜索树或者图的分支，直到⼀条路径上的所有节点都被遍历完毕，然后再回溯到上⼀层，继续找⼀条路遍历。在⼆叉树中，常见的深度优先遍历为：前序遍历、中序遍历以及后序遍历。因为树的定义本⾝就是递归定义，因此采⽤递归的方法去实现树的三种遍历不仅容易理解⽽且代码很简洁。
HDU - 2057 (纯C语言模拟16进制加减法)
qq_62224565的博客
08-05 325
首先将16进制转成10进制，再将10进制转成16进制。有个问题就是题目说输入不超过15位，但是。第二，使用abs函数时注意，当数爆int时，用long long 储存使用abs会有误。第一，多组输入注意清空字符数组，令每个字符等于’\0’即可。纯模拟，过了后发现可以用%x，直接输入输出。第三，模拟时记得用long long。以前做题没有怎么用C写过HDU的题。就是求16进制的加法。
关于哈希set和哈希map：
06-02
哈希set和哈希map都是基于哈希表实现的数据结构，不同之处在于哈希set只存储键，而哈希map存储键值对。这意味着，在哈希set中，每个键都必须是唯一的，而在哈希map中，每个键可以对应一个值。 哈希set和哈希map的底层实现都是使用哈希表。哈希表是一种高效的数据结构，可以实现快速的插入、查找和删除操作。哈希表的关键是哈希函数，它将键映射到哈希表中的桶中。当两个键映射到同一个桶时，就会发生哈希冲突。为了解决哈希冲突，哈希表使用链表或红黑树来存储冲突的键值对。 在使用哈希set和哈希map时，需要注意以下几点： 1. 哈希函数的设计需要尽可能均匀地将键映射到桶中，以避免发生哈希冲突。 2. 在插入、查找和删除操作时，需要先根据哈希函数将键映射到桶中，然后再在桶中进行操作。 3. 在使用哈希map时，需要注意键的唯一性，避免出现重复的键。 4. 哈希表的性能取决于哈希函数的效率和哈希表的负载因子，需要根据实际情况选择合适的哈希函数和哈希表大小。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值