set和map

已于 2022-06-05 15:31:48 修改
阅读量44 收藏
点赞数
分类专栏： C++ 文章标签： c++
于 2022-05-14 00:39:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46766926/article/details/124677465
版权

set和map

1、容器

1.1 序列式容器

vector、list、deque、forward_list和string 与vector等相关的容器都是序列式容器，其底层都是线性的数据结构，能够快速访问，存储元素本身。

1.2 关联式容器

与序列式容器不同，元素存储的位置由元素相关联的字值决定，因此在数据检索方面比序列式容器高。

2、键值对

用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息

3、树形结构的关联式容器

3.1 树型结构的关联式

容器主要有四种：map、set、multimap、multiset。这四种容器的共同点是：使用平衡搜索树(即红黑树)作为其底层结果，容器中的元素是一个有序的序列。

3.2 set

  1. set是按照一定次序存储元素的容器；
  2. 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。
  3. 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。set中的元素默认按照小于来比较
  4. set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代。
  5. set在底层是用平衡搜索树(红黑树)实现的。
  6. 与map/multimap不同，map/multimap中存储的是真正的键值对<key, value>，set中只放value，但在底层实际存放的是由<value, value>构成的键值对。
  7. set中插入元素时，只需要插入value即可，不需要构造键值对。
  8. 使用set的迭代器遍历set中的元素，可以得到有序序列
  9. set中查找某个元素，时间复杂度为：log2（n）

3.3 map

  1. map中的的元素是键值对
  2. map中的key是唯一的，并且不能修改
  3. 默认按照小于的方式对key进行比较
  4. map中的元素如果用迭代器去遍历，可以得到一个有序的序列
  5. map的底层为平衡搜索树(红黑树)，查找的时间复杂度为：log2（n）
  6. 支持[]操作符，operator[]中实际进行插入查找。

3.4 multiset

  1. multiset中再底层中存储的是<value, value>的键值对
  2. mtltiset的插入接口中只需要插入即可
  3. 与set的区别是，multiset中的元素可以重复，set是中value是唯一的
  4. 使用迭代器对multiset中的元素进行遍历，可以得到有序的序列
  5. multiset中的元素不能修改
  6. 在multiset中找某个元素，时间复杂度为log2（n）
  7. multiset的作用：可以对元素进行排序

3.5 multimap

  1. multimap中的key是可以重复的。
  2. multimap中的元素默认将key按照小于来比较
  3. multimap中没有重载operator[]操作，因为重复数据的查找不准确
  4. 使用时与map包含的头文件相同

4、AVL树

4.1概念

AVL是二叉搜索树，它的左右子树都是AVL树，且左右子树高度之差(简称平衡因子)的绝对值不超过1。
相比于普通的二叉搜索树，AVL树可以解决二叉搜索树有序或者接近有序数据的插入问题，提高效率，二叉搜索树的效率为N，而AVL树的效率为lon2（N）。

5、AVL树实现

5.1 结点

struct AVLTreeNode
{
	AVLTreeNode(const T& data = T())
		: _pLeft(nullptr)
		, _pRight(nullptr)
		, _pParent(nullptr)
		, _data(data)
		, _bf(0)
	{}
	AVLTreeNode<T>* _pLeft;//左孩子
	AVLTreeNode<T>* _pRight;//右孩子
	AVLTreeNode<T>* _pParent;//父亲
	T _data;
	int _bf;   // 结点的平衡因子,用来控制平衡
};

5.2 AVL树的插入

共两步：1.按照二叉搜索树的插入方式；2.调整平衡因子，如果在较高子树中插入数据，会导致树的不平衡，此时需要进行旋转，总共有4种情况的旋转。

5.2.1右单旋

新结点插入较高左子树的左侧，如下图：
图2在这里插入图片描述
图2在这里插入图片描述
如图2中在5的左子树插入一个数据，或者图2的中的h为0时，即图1中插入1时，需要进行右单旋，如下图：
在这里插入图片描述
使parent的左指针指向leftChildright，leftChild作此树的根结点，且它的右指针指向parent，然后调整父亲结点和平衡因子即可完成右单旋。需要注意的是，当parent不为该树的根时，要调整parent的父亲结点的指向。旋转完成后，调整的结点平衡因子均为0。

5.2.2左单旋

与右单旋类似，新结点插入较高右子树的右侧，如下图：
在这里插入图片描述

使parent的右指针指向rightChildleft，rightChild作此树的根结点，且它的左指针指向parent，然后调整父亲结点和平衡因子即可完成左单旋。同样的，当parent不为该树的根时，要调整parent的父亲结点的指向。旋转完成后，调整的结点平衡因子均为0。

5.2.3左右单旋

新节点插入较高左子树的右侧，如下图：
在这里插入图片描述
10的左子树较高，然后在左子树的右子树上插入数据。情况1下的旋转如图：
在这里插入图片描述
旋转完成后，要根据3种情况调整平衡因子。

5.2.4右左单旋

新节点插入较高右子树的左侧，如下图：
在这里插入图片描述
10的右子树较高，然后在右子树的左子树上插入数据。情况1下的旋转如图：
在这里插入图片描述
旋转完成后，要根据3种情况调整平衡因子。

6、AVL树的验证

先验证是否为二叉搜索树，再验证每个结点的字数的高度差是否小于1。
1.二叉搜索树的检验可以用中序遍历来检验；
2.高度差得检验可以用以下代码

bool IsAVLTree(Node* pRoot)
	{
		if (nullptr == pRoot) return true;
		// 计算pRoot左右子树的高度差
		int leftHeight = _Height(pRoot->_pLeft);
		int rightHeight = _Height(pRoot->_pRight);
		int diff = rightHeight - leftHeight;
		//如果差值不等于平衡因子或绝对值大于1，则平衡因子错误
		if (diff != pRoot->_bf || abs(diff)>1)
			return false;
		// 如果pRoot子树都是AVL树，则该树一定是AVL树
		return _IsAVLTree(pRoot->_pLeft) && _IsAVLTree(pRoot->_pRight);
	}
	//高度计算
	int _Height(Node* pRoot)
	{
		if(pRoot==nullptr)return 0;
		return max(_Height(pRoot->_pLeft)+1, _Height(pRoot->_pRight)+1);
	}

7、代码

#pragma once
#include<iostream>
#include<assert.h>
#include<algorithm>
using namespace std;
template<class T>
struct AVLTreeNode
{
	AVLTreeNode(const T& data = T())
		: _pLeft(nullptr)
		, _pRight(nullptr)
		, _pParent(nullptr)
		, _data(data)
		, _bf(0)
	{}

	AVLTreeNode<T>* _pLeft;
	AVLTreeNode<T>* _pRight;
	AVLTreeNode<T>* _pParent;
	T _data;
	int _bf;   // 结点的平衡因子
};
// AVL: 二叉搜索树 + 平衡因子的限制
template<class T>
class AVLTree
{
	typedef AVLTreeNode<T> Node;
public:
	AVLTree(): _pRoot(nullptr){}

	// 在AVL树中插入值为data的结点
	bool Insert(const T& data)
	{
		if (_pRoot == nullptr) {
			_pRoot = new Node(data);
			return true;
		}
		Node* parent = _pRoot, *cur = _pRoot;
		//找到data的位置
		while (cur) {
			if (cur->_data < data) {
				parent = cur;
				cur = cur->_pRight;
			}
			else if (cur->_data > data) {
				parent = cur;
				cur = cur->_pLeft;
			}
			else
				return false;
		}
		cur = new Node(data);
		if (parent->_data>data)
			parent->_pLeft = cur;
		else 
			parent->_pRight =cur;
		cur->_pParent = parent;
		//更改平衡因子
		while (cur != _pRoot){
			if (parent->_pLeft == cur)
				parent->_bf--;
			else
				parent->_bf++;
			//相当于补全子树，两子树平衡，停止向上的更改
			if (parent->_bf == 0)
				break;
			//继续向上更改
			else if (parent->_bf == 1 || parent->_bf == -1) {
				cur = parent;
				parent = parent->_pParent;
			}
			//左或右子树不平衡，旋转子树
			else if (parent->_bf == 2 || parent->_bf == -2) {
				if (parent->_bf == -2) {
					//右单旋，即在parent的较高左子树左侧插入
					if(cur->_bf==-1)
						RotateR(parent);
					//左右单旋，即在parent的较高左子树右侧插入
					if (cur->_bf == 1)
						RotateLR(parent);
				}
				else {
					//左单旋，即在parent的较高右子树右侧插入
					if (cur->_bf == 1)
						RotateL(parent);
					//右左单旋，即在parent的较高右子树左侧插入
					if (cur->_bf == -1)
						RotateRL(parent);
				}
				break;
			}
			else
				assert(false);
		}
		return true;
	}

	// AVL树的验证
	bool IsAVLTree()
	{
		return _IsAVLTree(_pRoot);
	}
	void InOrder()
	{
		_InOrder(_pRoot);
	}
private:
	// 根据AVL树的概念验证pRoot是否为有效的AVL树
	bool _IsAVLTree(Node* pRoot)
	{
		if (nullptr == pRoot) return true;
		// 计算pRoot左右子树的高度差
		int leftHeight = _Height(pRoot->_pLeft);
		int rightHeight = _Height(pRoot->_pRight);
		int diff = rightHeight - leftHeight;
		//如果差值不等于平衡因子或绝对值大于1，则平衡因子错误
		if (diff != pRoot->_bf || abs(diff)>1)
			return false;
		// 如果pRoot子树都是AVL树，则该树一定是AVL树
		return _IsAVLTree(pRoot->_pLeft) && _IsAVLTree(pRoot->_pRight);
	}
	int _Height(Node* pRoot)
	{
		if(pRoot==nullptr)return 0;
		return max(_Height(pRoot->_pLeft)+1, _Height(pRoot->_pRight)+1);
	}
	// 右单旋
	void RotateR(Node* pParent)
	{
		Node* parentParent = pParent->_pParent;
		Node* leftChild = pParent->_pLeft;
		Node* leftChildRight = leftChild->_pRight;
		//旋转，将父亲的左指向左孩子的右，左孩子的右指向父亲
		pParent->_pLeft = leftChildRight;
		leftChild->_pRight = pParent;
		//更改结点的父亲
		if (leftChildRight)
			leftChildRight->_pParent = pParent;
		pParent->_pParent = leftChild;
		leftChild->_pParent = parentParent;
		//若更改后子树的根结点的父亲为空，即为AVL树的根时，更新根,否则链接到父亲
		if (pParent == _pRoot) {
			_pRoot = leftChild;
			leftChild->_pParent = nullptr;
		}
		else{
			if (parentParent->_pLeft == pParent)
				parentParent->_pLeft = leftChild;
			else
				parentParent->_pRight = leftChild;
		}
		//更改平衡因子
		leftChild->_bf = pParent->_bf = 0;
	}
	// 左单旋
	void RotateL(Node* pParent)
	{
		Node* parentParent = pParent->_pParent;
		Node* rightChild = pParent->_pRight;
		Node* rightChildLeft = rightChild->_pLeft;
		//旋转，将父亲的右指向右孩子的左，右孩子的左指向父亲
		pParent->_pRight = rightChildLeft;
		rightChild->_pLeft = pParent;
		//更改结点的父亲
		if (rightChildLeft)
			rightChildLeft->_pParent = pParent;
		pParent->_pParent = rightChild;
		rightChild->_pParent = parentParent;
		//若更改后子树的根结点的父亲为空，即为AVL树的根时，更新根,否则链接到父亲
		if (pParent == _pRoot) {
			_pRoot = rightChild;
			rightChild->_pParent = nullptr;
		}
		else {
			if (parentParent->_pLeft == pParent)
				parentParent->_pLeft = rightChild;
			else
				parentParent->_pRight = rightChild;
		}
		//更改平衡因子
		rightChild->_bf = pParent->_bf = 0;
	}
	// 右左双旋
	void RotateRL(Node* pParent)
	{
		Node* rightChild = pParent->_pRight;
		Node* rightChildLeft = rightChild->_pLeft;
		int bf = rightChildLeft->_bf;
		RotateR(pParent->_pRight);
		RotateL(pParent);
		//更改平衡因子
		if (bf == 1) {
			rightChildLeft->_bf = rightChild->_bf = 0;
			pParent->_bf = -1;
		}
		else if (bf == -1) {
			pParent->_bf = rightChildLeft->_bf = 0;
			rightChild->_bf = 1;
		}
		else if (bf == 0) {
			pParent->_bf = rightChildLeft->_bf = rightChild->_bf = 0;
		}
		else
			assert(false);
	}
	// 左右双旋
	void RotateLR(Node* pParent)
	{
		Node* leftChild = pParent->_pLeft;
		Node* leftChildRight = leftChild->_pRight;
		int bf = leftChildRight->_bf;
		RotateL(pParent->_pLeft);
		RotateR(pParent);
		//更改平衡因子
		if (bf == 1) {
			leftChildRight->_bf = pParent->_bf = 0;
			leftChild->_bf = -1;
		}
		else if (bf == -1) {
			leftChild->_bf = leftChildRight->_bf = 0;
			pParent->_bf = 1;
		}
		else if (bf == 0) {
			pParent->_bf = leftChildRight->_bf = leftChild->_bf = 0;
		}
		else
			assert(false);
	}
	void _InOrder(Node*pRoot)
	{
		if (pRoot == nullptr)return;
		_InOrder(pRoot->_pLeft);
		cout << pRoot->_data << " ";
		_InOrder(pRoot->_pRight);
	}
private:
	Node* _pRoot;
};

#include"AVLTree.h"
int main()
{
	AVLTree<int> t;
	//int arr[] = { 5,9,4,2,3,10,0,7,8,1,6 };
	//int arr[] = { 5,4,3,2,1};//右单旋测试
	//int arr[] = {1,2,3,4,5};//左单旋测试
	//int arr[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	int arr[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	for (auto e : arr) {
		t.Insert(e);
		if (!t.IsAVLTree())
			cout << "error" << endl;
	}
	t.InOrder();
	return 0;
}
樂丶x
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Set和Map1
08-04
Set接口和Map接口是Java集合框架中的重要组成部分，它们提供了不同的数据存储和操作特性。 **Set接口** Set接口继承自Collection接口，它主要用于存储不重复的元素。在Set接口中，有以下常用的几个方法： 1. **add...
ES6中Symbol、Set和Map用法详解
10-16
在ES6中，JavaScript引入了三个新的数据结构：Symbol、Set和Map，它们为编程提供了更多的灵活性和便利性。下面将详细阐述这三个概念及其用法。 ### 1. Symbol **Symbol** 是一种全新的原始数据类型，它的值是...
Set和Map
weixin_43405946的博客
12-06 3215
Set是一种叫做集合的数据结构 Map是一种叫做字典的数据结构 应用场景：数据去重和数据存储 Set 集合是由一组无序且唯一的项组成的，可以想象成集合是一个既没有重复元素，也没有顺序概念的数组 ES6提供了新的数据结构Set，类似于数组，但是成员的值都是唯一的，没有重复的值 Set本身是一个构造函数，用来生成Set数据结构的 属性 size：返回字典所包含的元素个数 操作方法 add(value): 添加某个值，返回Set结构本身 delete(value)：删除某个值，返回一个布尔值，表.
Set 和 Map 的区别
努力学习前端的小白
01-18 2万+
Set和Map的区别
【C++】set和map
m0_62179366的博客
11-06 7291
map与set也十分的相似，map是K/V的模型，set是K的模型map也有两种区别与set和multiset相同，只是键值是否允许冗余的差别不过map的插入就比较特别了我们发现insert的参数是一个value_type类型然后我们发现它实际上是一个pair{T1 first;T2 second;{}{}};用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息。
set和map区别
m0_67400973的博客
03-23 1709
转自https://blog.csdn.net/terence1212/article/details/52487656 set是一种关联式容器，其特性如下： set以RBTree作为底层容器 所得元素的只有key没有value，value就是key 不允许出现键值重复 所有的元素都会被自动排序 不能通过迭代器来改变set的值，因为set的值就是键 map和set一样是关联式容器，它们的底层容器都是红黑树，区别就在于map的值不作为键，键和值是分开的。它的特性如下： map以RBTree作为底层容器
List,Set和Map详解
lucky多多的博客
08-28 1983
List,Set和Map详解List,Set和Map的使用场景 Java中的集合包括三大类：Set（集）、List（列表）和Map（映射），它们都处于java.util包中，Set、List和Map都是接口，它们有各自的实现类。Set的实现类主要有HashSet和TreeSet，List的实现类主要有ArrayList，Map的实现类主要有HashMap和TreeMap。 Collection是最...
ES6之Set和Map
旺旺旺小小苏的博客
03-17 2935
一、什么是Set 1）Set是一种叫做集合的数据结构。这句话的重点在于集合，那么什么是集合的？它又有什么特点呢？集合是由一组无序且唯一的项组成的，即是一个没有重复元素也没有顺序概念的数组 2）Set本身是一个构造函数，用来生成Set数据结构 二、Set的使用以及其实例的属性和方法 当我们要定义一个Set数据结构时： const setData = new Set() setData.add('111') // 或 const setData = new Set([111]） 1、属性： si
面试题---Set和Map的区别；Map和Object 的区别
muzidigbig的博客
12-17 6813
一、Set和Map的区别 简述： Set 和 Map 主要的应用场景在于 数据重组 和 数据储存。 Set 是一种叫做集合的数据结构，Map 是一种叫做字典的数据结构。 集合 与 字典 的区别： 共同点：集合、字典 可以储存不重复的值 不同点：集合 是以 [value, value]的形式储存元素，字典 是以 [key, value] 的形式储存 集合（Set）： ES6 新增的一种新的数据结构，类似于数组，成员唯一（内部元素没有重复的值）。且使用键对数据排序即顺序存储。 Set 本身是一种构
浅谈Set和Map的区别
Kodomo
11-10 4898
1. Map是键值对，Set是值的集合，当然键和值可以是任何的值； 2. Map可以通过get方法获取值，而set不能因为它只有值； 3. 都能通过迭代器进行for...of遍历； 4. Set的值是唯一的可以做数组去重，Map由于没有格式限制，可以做数据存储 5. map和set都是stl中的关联容器，map以键值对的形式存储，key=value组成pair，是一组映射关 系。set只有值，可以认为只有一个数据，并且set中元素不可以重复且自动排序。
ES6-Set和Map使用方法
热门推荐
来一颗砂糖橘
05-10 2万+
ES6-Set和Map使用方法
Set 和 Map 用法及介绍
liu_xiaoyang的博客
03-13 5373
数组： 紧密结构，可以排序，元素可以重复 查找需要遍历，查找速度慢，有长度 对象： 松散结构，键值对存在，键必须是字符和Symbol类型 添加删除速度快，不能排序，查找速度极快，没有长度 Set： 元素不能重复的集合，松散结构，插入删除速度快，不是键值对 查找需要遍历，有长度 Map： 键值对存在，类似于hashMap、类似于对象 对象的key只能是字符串或者Symbol，map的键可以是任何类型 map有长度 Set集合 1.创建Set ...
ES6中Set和Map用法实例详解
10-15
主要介绍了ES6中Set和Map用法,结合实例形式详细分析了ES6中Set和Map的基本功能、原理、使用方法及操作注意事项,需要的朋友可以参考下
ES6新增数据类型set和map
01-20
然而，随着编程需求的多样化，ES6（ECMAScript 2015）引入了两种新的数据类型——Set和Map，它们为数据的组织和处理提供了更强大的工具。 1、Set 1.1 Set的概念和声明 Set是一种特殊的集合，它不允许重复元素，类似...
java中list、set和map 的区别
12-22
在Java编程语言中，集合框架是处理对象的重要工具，其中包括三种主要的数据结构：List、Set和Map。这些数据结构在存储和操作数据方面各有特点，适用于不同的场景。 **List（列表）** List是一个有序的集合，它允许...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1314
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
VS2019编译和使用gtest测试（C++）
m0_65635427的博客
07-24 318
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
内网对抗-隧道技术篇&防火墙组策略&HTTP反向&SSH转发&出网穿透&CrossC2&解决方案
siu~
07-24 896
1、C2/C2上线-CrossC2插件-多系统平台支持 2、隧道技术篇-应用层-SSH协议-判断&封装&建立&穿透 3、隧道技术篇-应用层-HTTP协议-判断&封装&建立&穿透
【C++初阶】string类
最新发布
2301_78022459的博客
07-24 939
【C++初阶】string类
es6 set和map
07-27
- *1* *2* [ES6中的Map和Set详解](https://blog.csdn.net/m0_45093055/article/details/126430467)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值