set&&map&&AVL树&&红黑树

已于 2024-04-27 11:09:56 修改
阅读量691 收藏 25
点赞数 22
分类专栏： C++ 文章标签： c++
于 2024-04-21 14:45:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Raymood_/article/details/136984847
版权

目录

关联式容器

vector、list、deque、forward_list（c++11）等这些容器称为序列式容器。
因为其底层为线性序列的数据结构，里面存储的是元素本身。

关联式容器也是用来存储数据的，与序列式容器不同的是，他里面存储的是<key, value>结构的键值对，在数据检索时比序列是容器效率更高。

树形结构的关联式容器

根据应用场景的不同，STL总共实现了两种不同结构的管理是容器：树形结构和哈希。树形结构的关联式容器主要有四种：map、set、multimap、multiset。
这四种容器的共同点是：使用平衡搜索树（红黑树）作为其底层结果，容器中的元素是一个有序的序列。

set

set文档介绍
翻译：

  • set是按照一定的次序存储元素的容器。
  • 在set中，元素的value也标识他（value就是key，类型为T），并且每个value必须是唯一的。set中的元素不能在容器中修改（元素总是const），但可以从容器中插入或删除它们。
  • 在内部，set中的元素总是按照其内部比较对象（类型比较）所指示的特定严格若排序规则进行排序。
  • set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代。
  • set在底层是用二叉搜索树（红黑树）实现的。

set中的元素是不允许修改的，set的迭代器和const迭代器都是const迭代器。
在这里插入图片描述
在这里插入图片描述

set的模板参数列表

template < class T,                        // set::key_type/value_type
           class Compare = less<T>,        // set::key_compare/value_compare
           class Alloc = allocator<T>      // set::allocator_type
           > class set;

T：set中存放元素的类型，实际在底层存储<key, value>的键值对
Compare：set中元素默认按照小于来比较
Alloc：set中元素空间的管理方式i，使用STL提供的空间配置器管理

set的构造函数

//empty (1)	: 构造空的set
explicit set (const key_compare& comp = key_compare(),
              const allocator_type& alloc = allocator_type());
//range (2)	：用[first,last)区间中的元素构造set
template <class InputIterator>
  set (InputIterator first, InputIterator last,
       const key_compare& comp = key_compare(),
       const allocator_type& alloc = allocator_type());
//copy (3)	：set的拷贝构造
set (const set& x);

set的迭代器

函数声明功能介绍
iterator begin()返回set中起始位置元素的迭代器
iterator end()返回set中最后一个元素后面的迭代器
const_iterator cbegin() const返回set中起始位置元素的const迭代器
const_iterator cend() const返回set中最后一个元素后面的const迭代器
reverse_iterator rbegin()返回set第一个元素的反向迭代器
reverse_iterator rend()返回set最后一个元素下一个位置的反向迭代器，即rbegin
const_reverse_iterator crbegin() const返回set第一个元素的方向const迭代器，即cend
const_reverse_iterator crend() const返回set最后一个元素下一个位置的反向const迭代器

set的容量操作

函数声明功能介绍
bool empty() cosnt检测set是否为空，为空返回true；否则返回
iterator end()返回set中最后一个元素后面的迭代器
函数声明功能介绍
pair<iterator, bool> insert(const value_type &x)在set中插入元素x，实际插入的是<x,x>构成的键值对。如果插入成功，返回<该元素在set中的位置，true>；如果插入失败，说明x在set中已经存在，返回<x在set中的位置,false>
void erase(iterator position)删除set中position位置上的元素
size_type erase(const key_type &x)删除set中值为x的元素，返回删除元素的个数
void erase(iterator first, iterator last)删除set中[first, last)区间的元素
void swap(set<key, Compare, Allocator>&st)交换set中的元素
void clear()将set中的元素清空
iterator find(const key_type& x) const返回set中值为x的元素的位置
size_type count(const key_type& x)const返回set中值为x的元素的个数

set其他操作

find

iterator find (const value_type& val) const;
返回值：
	成功返回一个指向要查找元素的迭代器；失败则返回std::end

void test_find()
{
	set<int> s;
	s.insert(3);
	s.insert(2);
	s.insert(4);
	s.insert(5);
	s.insert(1);
	set<int>::iterator pos = s.find(5);
	if (pos != s.end())
	{
		cout << "找到了：" << *pos << endl;
	}
	cout << endl;
	s.erase(s.find(3));
	for (auto e : s)
	{
		cout << e <<" ";
	}
	cout << endl;
}
//输出：
//找到了：5
//
//1 2 4 5
//

count

功能：判断所要查找的元素在不在set中。
size_type count (const value_type& val) const;
返回值：
	成功返回1；失败则返回0.

void test_count()
{
	set<int> s;
	s.insert(3);
	s.insert(2);
	s.insert(4);
	s.insert(5);
	s.insert(1);
	set<int>::iterator pos = s.find(5);
	if (s.count(5))
	{
		cout << *pos << " 找到了" << endl;
	}
}
//输出：
//5 找到了
//

lower_bound && upper_bound

功能：返回给定值在set中第一个大于等于该值的迭代器                    	功能：返回给定值在set中第一个大于该值的迭代器
iterator lower_bound (const value_type& val) const;			    iterator upper_bound (const value_type& val) const;**

void test_bound()
{
	set<int> myset;
	set<int>::iterator itlow, itup;

	for (int i = 1; i < 10; i++)
	{
		myset.insert(i * 10);
	}
	//myset:10 20 30 40 50 60 70 80 90

	itlow = myset.lower_bound(35);
	itup = myset.upper_bound(60);
	cout << "itlow: " << *itlow << endl;
	cout << "itlow: " << *itup << endl;
	myset.erase(itlow, itup);//erase是左闭右开的，[40, 70)
	//迭代器对于区间的控制，要求区间必须是左闭右开。所以取下边界用lower_bound，取上边界用upper_bound
	for (auto e : myset)
	{
		cout << e << " ";
	}
	cout << endl;
}
//输出：
//itlow: 40
//itlow: 70
//10 20 30 70 80 90
//

equal_range

pair<iterator,iterator> equal_range (const value_type& val) const;

void test_equal_range()
{
	set<int> myset;
	set<int>::iterator itlow, itup;

	for (int i = 1; i < 10; i++)
	{
		myset.insert(i * 10);
	}
	//myset:10 20 30 40 50 60 70 80 90
	pair<set<int>::const_iterator, set<int>::const_iterator> ret;
	ret = myset.equal_range(30);
	itlow = ret.first;
	itup = ret.second;
	cout << "itlow: " << *itlow << endl;
	cout << "itlow: " << *itup << endl;
}
//输出：
//itlow: 30
//itlow: 40
//

multiset

multiset文档介绍
翻译：

  • multiset是按照特定顺序存储元素的容器，其中元素是可以重复的（multiset就是允许键值冗余的set）。
  • 在multiset中，元素的value也会识别他（因为multiset本身存储的就是<value,value>组成的键值对）。因此value本身就是key，key和就是value，类型为T（）。multiset元素的值不能再容器中进行修改（因为元素总是const的），但可以从容器中插入或删除。
  • 在内部，multiset中的元素总是按照其内部比较规则（类型比较）所指示的特定严格弱排序准则进行排序。
  • multiset容器通过key访问单个元素的速度通常比unordered_multiset容器慢，但使用迭代器遍历时会得到一个有序序列。
  • multiset底层结构为二叉搜索树（红黑树）。

注意：
multiset的插入接口中只需要插入即可。
在multiset中找某个元素时间复杂度为： O ( l o g 2 N ) O(log_2N) O(log2​N)
multiset的作用可以对元素进行排序。

void test_multiset()
{
	multiset<int> s;
	s.insert(3);
	s.insert(2);
	s.insert(3);
	s.insert(4);
	s.insert(3);
	s.insert(5);
	s.insert(1);
	s.insert(3);
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;

	cout << "cout:" << s.count(3) << endl;
	
	pair<set<int>::const_iterator, set<int>::const_iterator> ret = s.equal_range(3);
	set<int>::iterator itlow = ret.first;
	set<int>::iterator itup = ret.second;
	cout << "itlow: " << *itlow << endl;
	cout << "itlow: " << *itup << endl;

	s.erase(itlow, itup);
	for (auto e : s)
	{
		cout << e << " ";
	}
	cout << endl;
}
//输出：

//1 2 3 3 3 3 4 5
//cout:4
//itlow: 3
//itlow: 4
//1 2 4 5
//

map

map文档介绍

翻译：

  • map是关联容器，它按照特定的次序（按照key来比较）存储由键值key和值value组合而成的元素。

  • 在map中，键值key通常用于排序和唯一地标识元素，而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同，并且在map的内部，key与value通过成员类型value_type绑定在一起，并为取别名为pair。

  • 在这里插入图片描述

  • 在内部，map中的元素总是按照键值key进行比较排序的。

  • map中通过键值访问单个元素的速度通常比unordered_map容器慢，但map允许根据顺序对元素进行直接迭代（即对map中的元素进行迭代时，可以得到一个有序的序列）。

  • map支持下标访问符，即在[]中放入key，就可以找到key与对应的value。

  • map通常被实现为二叉搜索树（更准确的说是：平衡二叉树（红黑树））。

键值对

set中是将set的普通迭代器typedef成const迭代器，从而致使set中的元素无法被修改。
但map不能采用这种一刀切的手法，map只少要能修改value。
在这里插入图片描述
所以map用一个名为pair的键值对来对数据进行存储。

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

//SGI-STL中关于键值对的定义
template<class T1, class T2>
struct pair
{
	typedef T1 first_type;
	typedef T2 second_type;

	T1 first;
	T2 second;
	pair()
	:first(T1())
	,second(T2())
	{}
	
	pair(const T1 &a, const T2 &b)
	:first(a)
	,second(b)
	{}
};

比如：英汉互译的字典，字典中必然有英文单词和对应的中文译义。而且，英文单词与中文译义是一一对应的关系，即通过英文单词，就可以在字典中查找到其对应的中文译义。

void dict()
{
	map<string, string> dict;//这里的第一个string，不用特意写成const，map内部会自动转换
	pair<string, string>kv1("insert", "插入");
	dict.insert(kv1);
	dict.insert(pair<string, string>("sort", "排序"));
	dict.insert(make_pair("string", "字符串"));//C++98
	dict.insert({ "iterator","迭代器" });//C++11支持了多参数类型的隐式类型转换，这样子写等价于调用pair
}

map的模板参数列表

template < class T,                        // multiset::key_type/value_type
           class Compare = less<T>,        // multiset::key_compare/value_compare
           class Alloc = allocator<T> >    // multiset::allocator_type
           > class multiset;
  • key：键值对中key的类型
  • T：键值对中value的类型
  • Compare：比较器的类型

map的迭代器

函数声明功能介绍
begin()和end()begin：首元素的位置，end最后一个元素的下一个位置
cbegin()和cend()与begin和end意义相同，但cbegin和cend所指向的元素不能修改
rbegin()和rend()反向迭代器，rbegin在end位置，rend在begin位置，其++和–操作与begin和end操作移动相反
crbegin()和crend()与rbegin和rend位置相同，操作相同，但crbegin和crend所指向的元素不能修改

map中元素的修改

函数声明功能简介
pair<iterator, bool>insert(const value_type& x)在map中插入键值对x，注意x是一个键值对，返回值也是键值对；iterator代表新插入元素的位置，bool代表释放插入成功
void erase(iterator position)删除position位置上的元素
size_type erase(const key_type& x)删除键值为x的元素
void erase(iterator first, iterator last)删除[first, last)区间中的元素
vodi swap(map<Key, T, Compare, Allocator>&mp)交换两个map中的元素
void clear()将map中的元素清空
iterator find(const key_type& x)在map中插入key为x的元素，找到返回该元素的位置的迭代器，否则返回end
const_iterator find(const key_type& x) const在map中插入key为x的元素，找到返回该元素的位置的const迭代器，否则返回cend
size_type count(const key_type& x) const返回key为x的键值在map中的个数，注意map中key是唯一的，英雌该函数的返回值要么为0，要么为1，因此也可以用该函数来检测一个key是否在map中
//统计次数
void test_count()
{
	string arr[] = { "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉" };
	map<string, int> countMap;
	for (auto e : arr)
	{
		auto it = countMap.find(e);
		if (it == countMap.end())
		{
			countMap.insert(make_pair(e, 1));
		}
		else
		{
			it->second++;
		}
	}
	for (const auto& kv : countMap)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
}
//输出：
//苹果:4
//西瓜:4
//香蕉:1
//

map的容量与元素访问

函数声明功能简介
bool empty() const检测map中的元素是否为空，是返回true，否则返回false
size_type size() const返回map中有效元素的个数
mapper_type &operator[](const key_type& k)返回去key对应的value

map::operator[]

mapped_type& operator[] (const key_type& k);

在这里插入图片描述
map的[]，接受的是key，返回的是value。

  • operator[]的原理是：
  • 用<key, T()>构造一个键值对，然后调用insert()函数将该键值对插入到map中。
  • 如果key已经存在，插入失败，insert函数返回该key所在位置的迭代器。
  • 如果key不存在，插入成功，insert函数返回新插入元素所在位置的迭代器。
//所以对于上面的统计次数代码可以用[]来进行简化
void test_count()
{
	string arr[] = { "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉" };
	map<string, int> countMap;
	//for (auto e : arr)
	//{
	//	auto it = countMap.find(e);
	//	if (it == countMap.end())
	//	{
	//		countMap.insert(make_pair(e, 1));
	//	}
	//	else
	//	{
	//		it->second++;
	//	}
	//}
	for (auto e : arr)
	{
		countMap[e]++;
	}
	for (const auto& kv : countMap)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
}
//输出：
//苹果:4
//西瓜:4
//香蕉:1
//

//[]的运用
void test_map2()
{
	map<string, string>dict;
	dict.insert(make_pair("string", "字符串"));
	dict.insert(make_pair("sort", "排序"));
	dict.insert(make_pair("insert", "插入"));

	cout << dict["sort"] << endl;//查找和读
	dict["map"];//插入
	dict["map"] = "映射";//修改
	dict["insert"] = "xxx";//修改
	dict["set"] = "集合";//插入+修改

	for (const auto& kv : dict)
	{
		cout << kv.first << ":" << kv.second << endl;
	}
}
//输出：
//排序
//insert:xxx
//map:映射
//set:集合
//sort:排序
//string:字符串
//

multimap

multimap文档
翻译：

  • multimap是关联式容器，他按照特定的顺序，存储由key和value映射成的键值对<key,value>,其中多个键值对之间的key是可以重复的。
  • 在multimap中，通常按照key排序和唯一地标识元素，而映射地value存储与key关联的内容。key和value的类型可能不同，通过multimap内部的成员类型value_type组合在一起value_type是组合key和value的键值对：typedef pair<const Key, T> value_type;
  • 在内部，multimap中的元素总是通过其内部比较对象，按照指定的特定严格弱排序标准对key进行排序。
  • multimap通过key访问单个元素的速度通常比unordered_multimap容器慢，但是使用迭代器直接遍历multimap中的元素可以得到关于key有序的序列
  • multimap在底层用二叉搜索树（红黑树）来实现

multimap和map唯一不同的就是：map中key是唯一的，而multimap中的key是可以重复的。
multimap中的接口可以参考map，功能都是类似的。

底层结构

前面的map/multimap/set/multiset，这几个容器有个共同点：其底层都是按照二叉搜索树来实现的。但二叉搜索树自身是有缺点的：假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单只树，时间复杂度会退换成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。

avl树

avl树概念

二叉搜索树随可以缩短查找的效率 ，但如果数据有序或者接近有序二叉搜索树将退化成单支树，查找元素相当于再顺序表中搜索元素，效率低下。
在这里插入图片描述

数据有序或者接近有序二叉搜索树将退化成单支树

因此，有一种解决上述问题的方法：当想二叉搜索树中插入新节点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1（需要对树中的结点进行调整），即可降低树的高度，从而减少平均搜索长度。
一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

  • 它的左右子树都是AVL树
  • 左右子树高度之差（简称平衡因子）的绝对值不超过1（-1/0/1）
    在这里插入图片描述

如果一颗二叉搜索树是高度平衡的，它就是AVL树、如果他有n个结点，其高度可保持在 O ( l o g 2 n ) O(log_2n) O(log2​n)，搜索时的时间复杂度： O ( l o g 2 n ) O(log_2n) O(log2​n)。

在这里插入图片描述

AVL树结点的定义

template<class T>

struct AVLTreeNode//如果用class 记得给public
{
	AVLTreeNode(const T& data)
		:_pLeft(nullptr)
		,_pRight(nullptr)
		,_pParent(nullptr)
	{}
	AVLTreeNode<T>* _pleft;//该节点的左孩子
	AVLTreeNode<T>* _pright;//该节点的右孩子
	AVLTreeNode<T>* _pParent;//该节点的双亲
	T _data;
	int _bf;//该节点的平衡因子//balance factor
};

AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。
那么AVL树的插入的插入过程可以分成两步：
1.按照二叉搜索树的方式插入新节点
2.调整节点的平衡因子

在这里插入图片描述

template<class K, class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		//1. 按照二叉搜索树的方式插入新节点
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.frist)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(kv);
		if (parent->_kv.first < kv.first)//与父节点比较，大于父节点放右边
		{
			parent->_right = cur;
		}
		else//if (parent->_kv.first > kv.fist)//小于父节点放左边
		{
			parent->_left = cur;
		}
		cur->_parent = parent;//保存父节点

		//控制平衡
		//更新平衡因子
		while (parent)
		{
			//更新双亲的平衡因子
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else //if (cur == parent->_right)
			{
				parent->_bf++;
			}
			if (parent->_bf == 0)
			{
				//更新结束
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				//继续往上更新
				break;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//子树不平衡了，需要旋转
				break;//平衡后会降低这个子树的高度，所以满足break的条件
			}
			else
			{
				assert(false);
			}
		}
		return true;
	}

AVL树的旋转

如果在一颗原本是平衡的AVL树中插入一个新节点，可能造成不平衡，此时必须调整书的结构，使之平衡化。

旋转的时候需要注意的问题：
1. 保持他依旧是搜索树
2. 变成平衡树且降低这个子树的高度

根据节点插入位置的不同，AVL树的旋转分为四种：

  1. 新节点插入较高右子树的右侧–右右：左单旋
    在这里插入图片描述
左单旋 
void RotateL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;

		parent->_right = curleft;
		if (curleft)//curLeft可能为空
		{
			curleft->_parent = parent;
		}

		cur->_left = parent;
		Node* ppnode = parent->_parent;//ppnode == parent's parent
		parent->_parent = cur;

		if (parent == _root)//判断这棵树是不是子树
		{
			_root = cur;
			cur->_parent = nullpptr;//根节点的父节点指向空
		}
		else//这颗不平衡的树是一颗子树
		{//还得判断这颗子树在其父节点的左边还是右边
			if (ppnode->_left = parent)//左
			{
				ppnode->_left = cur;
			}
			else//右
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
		parent-> _bf = cur->_bf = 0;
	}
  1. 新节点插入较高左子树的左侧–左左：右单旋
    在这里插入图片描述
右单旋 
void RotateR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curRight = cur->_right;

		parent->_left = curRight;
		if (curRight)//curLeft可能为空
		{
			curRight->_parent = parent;
		}

		cur->_right = parent;
		Node* ppnode = parent->_parent;//ppnode == parent's parent
		parent->_parent = cur;

		if (parent == _root)//判断这棵树是不是子树
		{
			_root = cur;
			cur->_parent = nullptr;//根节点的父节点指向空
		}
		else//这颗不平衡的树是一颗子树
		{//还得判断这颗子树在其父节点的左边还是右边
			if (ppnode->_left == parent)//左
			{
				ppnode->_left = cur;
			}
			else//右
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
		parent->_bf = cur->_bf = 0;
	}
  1. 新节点插入较高右子树的左侧–右左：先右单旋再左单旋
    在这里插入图片描述
右左单旋 
	void RotateRL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;
		int bf = curleft->_bf;

		RotateR(parent->_right);
		RotateL(parent);
		if (bf == 0)
		{
			cur->_bf = 0;
			curleft->_bf = 0;
			parent->_bf = 0;
		}
		else if (bf == -1)
		{
			cur->_bf = 0;
			curleft->_bf = 0;
			parent->_bf = -1;
		}
		else if (bf == 1)
		{
			cur->_bf = 1;
			curleft->_bf = 0;
			parent->_bf = -1;
		}
		else
		{
			assert(false);
		}
	}
  1. 新节点插入较高左子树的右侧–左右：先左单旋再右单旋
    在这里插入图片描述
右左单旋 
void RotateLR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curRight = cur->_left;
		int bf = curRight->_bf;

		RotateL(parent->_left);
		RotateR(parent);
		
		if (bf == 0)
		{
			parent->_bf = 0;
			cur->_bf = 0;
			curRight->_bf = 0;
		}
		else if (bf == -1)
		{
			parent->_bf = 1;
			cur->_bf = 0;
			curRight->_bf = 0;
		}
		else if (bf == 1)
		{
			parent->_bf = 0;
			cur->_bf = -1;
			curRight->_bf = 0;
		}
	}

总结
假设以parent为根的子树不平衡，即parent的平衡因子为-2或2，可分以下情况考虑

  1. parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为curRight
  • 当curRight的平衡因子为1时，执行左单旋
  • 当curRight的平衡因子为-1时，执行右左双旋
  1. parent的平衡因子为-2时，说明parent的左子树高，设parent的左子树的根为curLeft
  • 当curLeft的平衡因子为-1时，执行右单旋
  • 当curleft的平衡因子为1时，执行左右双旋

AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步走：

  1. 验证其位二叉搜索树
  • 如果中序遍历的到了一个有序的序列，就说明是二叉搜索树
  1. 验证其为平衡树
  • 每个节点子树的高度的绝对值不超过1
  • 节点的平衡因子是否计算正确
int Height()
	{
		return Height(_root);
	}

	int Height(Node* root)
	{
		if (root == nullptr)
		{
			return 0;
		}
		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}
	
	bool _IsBalance(Node* root)//确认树是不是平衡的	
	{
		if (root == nullptr)//空树姑且也算平衡的
		{
			return true;
		}
		int leftHeight = Height(root->_left);//左子树高度=
		int rightHeight = Height(root->_right);//右子树高度

		if (rightHeight - leftHeight != root->_bf)//检测一下之前写的平衡因子对不对
		{
			cout << "平衡因子异常" << root->_kv.first << "->" << root->_bf << endl;
		}
		return false;

		return abs(rightHeight - leftHeight) < 2
			&& _IsBalance(root->_left)
			&& _IsBalance(root->_right);
	}

AVL树的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求是每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即 l o g 2 N log_2N log2​N。但是如果要对AVL树做一些结构性的修改操作，性能会非常低下。比如：插入时要维护其绝对平衡，旋转的次数比较多；更差的是删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的（即不会改变），可以考虑AVL树；但如果是一种结构经常修改，就不太适合。

红黑树

红黑树概念

红黑树，是一种二叉搜索树，但在每个节点上增加一个存储位以表示节点的颜色，可以是红色或者黑色。通过任何一条从根到叶子的路径上各个节点颜色的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是接近平衡的。
在这里插入图片描述

红黑树中最短的路径：红节点最少的路径
最长的路径：一黑一红相间的路径

红黑树的性质

  1. 每个节点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的，则他的两个孩子节点是黑色的（任何路径没有连续的红色节点）
  4. 对于每个节点，从该节点到其所有后代叶节点的简单路径上，均包含数目相同的黑色节点（每条路径上的黑色节点的数量相等）
  5. 每个叶子节点都是黑色的，这里的叶子节点指的是空节点–NIL（NIL叶节点都是黑色的）

红黑树的插入操作

红黑树是在二叉搜索树的基础上加入其限制平衡条件，因此红黑树的插入课分为两步：
1.按照二叉搜索树的规则插入节点
2.检测新节点插入后，红黑树的性质是否遭到破坏
因为新节点默认的颜色是红色，因此：
如果其父节点的颜色是黑色，则没有违反红黑树的任何性质，则不需要调整
但当新插入节点的父节点颜色为红色时，就违反了性质3（不能有连在一起的红色节点）。此时就需要对红黑树分情况讨论。
约定：cur为当前节点、p为父节点、g为祖父节点、u为叔叔节点

情况一：cur为红，p为红，g为黑，u存在且为红
ps：此处的树，可能是一棵完整的树，也可能是一颗子树
解决方式：将p、u改为黑色，g改为红。然后把g当成cur，继续向上调整。
在这里插入图片描述

情况一

如果g是根节点。调整完以后，需要将g改为黑色。
如果g是子树，g一定有父节点。且g的父节点如果是红色，则需要继续向上调整。
在这里插入图片描述

情况一

情况二:cur为红，p为红，g为黑，u不存在/u为黑
u的情况有两种：
1.如果u不存在，则cur一定是新插入的节点。因为如果cur不是新插入的节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质四（每条路径黑色节点个数相同）
2.如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的。
解决方式：
1.p为g的左孩子，cur为p的左孩子，则进行右单旋转
2.p为g的右孩子孩子，cur为p的右孩子，则进行左单旋转

在这里插入图片描述

情况二：p为g的左孩子，cur为p的左孩子

在这里插入图片描述

情况二：p为g的右孩子孩子，cur为p的右孩子 
bool Insert(const pair<K, V>& kv)
	{
		//按照二叉搜索树的方式插入新节点... 
		//新节点插入后，如果其双亲节点的颜色为空色，则违反性质3(不能有连在一起的红色结点)
		while (parent && parent->_color == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//u存在且为红
				if (uncle && uncle->_col == RED)
				{
					//变色
					parent->_color = uncle->_color = BLACK;
					grandfather->_color = RED;
					//继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//u不存在或存在且为黑
				{
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_color = BLACK;
						grandfather->_color = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						cur->_color = BLACK;
						grandfather->_color = RED;
					}
				}
			}
			else// if(parent == grandfather->_right)
			{
				Node* uncle = grandfather->_left;
				//u存在且为红
				if (uncle && uncle->_col == RED)
				{
					//变色
					parent->_color = uncle->_color = BLACK;
					grandfather->_color = RED;
					//继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//u不存在或存在且为黑
				{
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_color = BLACK;
						grandfather->_color = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_color = BLACK;
						grandfather->_color = RED;
					}

					break;
				}
			}
		}
		_root->_color = RED;
		return true;
	}
	
	//复用AVL树的左单旋
	void RotateL(Node* parent)
	{
		Node* cur = parent->_right;
		Node* curleft = cur->_left;

		parent->_right = curleft;
		if (curleft)//curLeft可能为空
		{
			curleft->_parent = parent;
		}

		cur->_left = parent;
		Node* ppnode = parent->_parent;//ppnode == parent's parent
		parent->_parent = cur;

		if (parent == _root)//判断这棵树是不是子树
		{
			_root = cur;
			cur->_parent = nullptr;//根节点的父节点指向空
		}
		else//这颗不平衡的树是一颗子树
		{//还得判断这颗子树在其父节点的左边还是右边
			if (ppnode->_left == parent)//左
			{
				ppnode->_left = cur;
			}
			else//右
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
	}

	//复用AVL树的右单旋
	void RotateR(Node* parent)
	{
		Node* cur = parent->_left;
		Node* curRight = cur->_right;

		parent->_left = curRight;
		if (curRight)//curLeft可能为空
		{
			curRight->_parent = parent;
		}

		cur->_right = parent;
		Node* ppnode = parent->_parent;//ppnode == parent's parent
		parent->_parent = cur;

		if (parent == _root)//判断这棵树是不是子树
		{
			_root = cur;
			cur->_parent = nullptr;//根节点的父节点指向空
		}
		else//这颗不平衡的树是一颗子树
		{//还得判断这颗子树在其父节点的左边还是右边
			if (ppnode->_left == parent)//左
			{
				ppnode->_left = cur;
			}
			else//右
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
	}

红黑树的验证

  • 红黑树的验证检测也分为两步：
  1. 检测其是否满足二叉搜素树（中序遍历是否为有序数列）
  2. 检测其是否满足红黑树性质
	bool CheckColour(Node* root, int blacknum, int benchmark)
	{
		if (root == nullptr)
		{
			if (blacknum != benchmark)
				return false;

			return true;
		}

		if (root->_color == BLACK)
		{
			++blacknum;
		}

		if (root->_color == RED && root->_parent && root->_parent->_color == RED)
		{
			cout << root->_kv.first << "出现连续红色节点" << endl;
			return false;
		}

		return CheckColour(root->_left, blacknum, benchmark)
			&& CheckColour(root->_right, blacknum, benchmark);
	}

	bool IsBalance()
	{
		return IsBalance(_root);
	}

	bool IsBalance(Node* root)
	{
		if (root == nullptr)
			return true;

		if (root->_color != BLACK)
		{
			return false;
		}

		// 基准值
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_color == BLACK)
				++benchmark;

			cur = cur->_left;
		}

		return CheckColour(root, 0, benchmark);
	}

红黑树与AVL树比较

红黑树和AVL树都是高效的平衡二叉树，增删查改的时间复杂度都是 O ( l o g 2 N ) O(log_2N) O(log2​N),红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的两倍。相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单。

简单模拟实现set和map

改造红黑树

#pragma once
#include<iostream>

using namespace std;

//节点的颜色
enum Color { RED, BLACK };

//红黑树节点的定义
template <class T>
class RBTreeNode
{
public:
	RBTreeNode(const T& data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		,_data(data)
		,_color(RED)
	{}
	 
	RBTreeNode<T>* _left;//节点的左孩子
	RBTreeNode<T>* _right;//节点的右孩子
	RBTreeNode<T>* _parent;//节点的父节点
	T _data;//节点的值域
	Color _color;//节点的颜色
};


template<class T, class Ptr, class Ref>
class __TreeIterator
{
	typedef RBTreeNode<T> Node;
public:
	typedef __TreeIterator<T, Ptr, Ref > Self;
	typedef __TreeIterator<T, T*, T&> Iterator;

	__TreeIterator(const Iterator& it)
		:_node(it._node)
	{}

	Node* _node;

	__TreeIterator(Node *node)
		:_node(node)
	{}

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

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

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

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

	Self& operator--()
	{
		if (_node->_left)
		{
			Node* subRight = _node->_left;
			while (subRight->_right)
			{
				subRight = subRight->_right;
			}
			_node = subRight;
		}
		else
		{
			//孩子是父亲右的节点
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == cur->_left)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}

	Self& operator++()
	{
		if (_node->_right)//1. 右不为空，访问右树的最左节点（最小节点）
		{
			Node* subLeft = _node->_right;
			while (subLeft->_left)
			{
				subLeft = subLeft->_left;
			}
			_node = subLeft;
		}
		else//2. 右为空，下一个访问的是孩子是父亲左的那个祖先节点
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent)
			{
				if (cur == parent->_left)
				{
					break;
				}
				else
				{
					cur = cur->_parent;
					parent = parent->_parent;
				}
			}
			_node = parent;
		}
		return *this;
	}
};

//set->RBTree<K, pair<K, K, SetKeyOfT> _t;
//map->RBTree < K, pair<K, V>, MapKeyOfT> _t;
template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef __TreeIterator<T, T*, T&> iterator;
	typedef __TreeIterator<T, const T*, const T&> const_iterator;

	iterator begin()
	{
		Node* leftMin = _root;
		while (leftMin && leftMin->_left)
		{
			leftMin = leftMin->_left;
		}
		return iterator(leftMin);
	}

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

	const_iterator begin() const
	{
		Node* leftMin = _root;
		while (leftMin && leftMin->_left)
		{
			leftMin = leftMin->_left;
		}

		return const_iterator(leftMin);
	}

	const_iterator end() const
	{
		return const_iterator(nullptr);
	}

	Node* Find(const K& key)
	{
		Node* cur = _root;
		KeyOfT kot;
		while (cur)
		{
			if (kot(cur->_data) < key)
			{
				cur = cur->_right;
			}
			else if (kot(cur->_data) > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}

		return nullptr;
	}

	pair<iterator, bool> Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_color = BLACK;
			return make_pair(iterator(_root), true);
		}
		//1. 按照二叉搜索树的方式插入新节点
		Node* parent = nullptr;
		Node* cur = _root;

		KeyOfT kot;
		while (cur)
		{
			if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data)> kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return make_pair(iterator(cur), false);
			}
		}

		cur = new Node(data);
		cur->_color = RED;
		Node* newnode = cur;

		if (kot(parent->_data) < kot(data))//与父节点比较，大于父节点放右边
		{
			parent->_right = cur;
		}
		else//if (parent->_kv.first > kv.fist)//小于父节点放左边
		{
			parent->_left = cur;
		}
		cur->_parent = parent;//保存父节点


		//新节点插入后，如果其双亲节点的颜色为空色，则违反性质3(不能有连在一起的红色结点)
		while (parent && parent->_color == RED)
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//u存在且为红
				if (uncle && uncle->_color == RED)
				{
					//变色
					parent->_color = uncle->_color = BLACK;
					grandfather->_color = RED;
					//继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//u不存在或存在且为黑
				{
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_color = BLACK;
						grandfather->_color = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						cur->_color = BLACK;
						grandfather->_color = RED;
					}
					break;
				}
			}
			else// if(parent == grandfather->_right)
			{
				Node* uncle = grandfather->_left;
				//u存在且为红
				if (uncle && uncle->_color == RED)
				{
					//变色
					parent->_color = uncle->_color = BLACK;
					grandfather->_color = RED;
					//继续向上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else//u不存在或存在且为黑
				{
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_color = BLACK;
						grandfather->_color = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_color = BLACK;
						grandfather->_color = RED;
					}

					break;
				}
			}
		}
		_root->_color = BLACK;
		return make_pair(iterator(newnode), true);
	}

	//复用AVL树的左单旋
	void RotateL(Node* parent)
	{
		++_rotateCount;
		Node* cur = parent->_right;
		Node* curleft = cur->_left;

		parent->_right = curleft;
		if (curleft)//curLeft可能为空
		{
			curleft->_parent = parent;
		}

		cur->_left = parent;
		Node* ppnode = parent->_parent;//ppnode == parent's parent
		parent->_parent = cur;

		if (parent == _root)//判断这棵树是不是子树
		{
			_root = cur;
			cur->_parent = nullptr;//根节点的父节点指向空
		}
		else//这颗不平衡的树是一颗子树
		{//还得判断这颗子树在其父节点的左边还是右边
			if (ppnode->_left == parent)//左
			{
				ppnode->_left = cur;
			}
			else//右
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
	}

	//复用AVL树的右单旋
	void RotateR(Node* parent)
	{
		++_rotateCount;
		Node* cur = parent->_left;
		Node* curRight = cur->_right;

		parent->_left = curRight;
		if (curRight)//curLeft可能为空
		{
			curRight->_parent = parent;
		}

		cur->_right = parent;
		Node* ppnode = parent->_parent;//ppnode == parent's parent
		parent->_parent = cur;

		if (ppnode == nullptr)//判断这棵树是不是子树
		{
			_root = cur;
			cur->_parent = nullptr;//根节点的父节点指向空
		}
		else//这颗不平衡的树是一颗子树
		{//还得判断这颗子树在其父节点的左边还是右边
			if (ppnode->_left == parent)//左
			{
				ppnode->_left = cur;
			}
			else//右
			{
				ppnode->_right = cur;
			}
			cur->_parent = ppnode;
		}
	}

	bool CheckColour(Node* root, int blacknum, int benchmark)
	{
		if (root == nullptr)
		{
			if (blacknum != benchmark)
				return false;

			return true;
		}

		if (root->_color == BLACK)
		{
			++blacknum;
		}

		if (root->_color == RED && root->_parent && root->_parent->_color == RED)
		{
			cout << root->_kv.first << "出现连续红色节点" << endl;
			return false;
		}

		return CheckColour(root->_left, blacknum, benchmark)
			&& CheckColour(root->_right, blacknum, benchmark);
	}

	bool IsBalance()
	{
		return IsBalance(_root);
	}

	bool IsBalance(Node* root)
	{
		if (root == nullptr)
			return true;

		if (root->_color != BLACK)
		{
			return false;
		}

		// 基准值
		int benchmark = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_color == BLACK)
				++benchmark;

			cur = cur->_left;
		}

		return CheckColour(root, 0, benchmark);
	}

	int Height()
	{
		return Height(_root);
	}

	int Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

private:
	Node* _root = nullptr;

public:
	int _rotateCount = 0;
};

set的模拟实现

#pragma once
#include"RBTree.h"

namespace yzk
{
	template<class K>
	class set
	{
	public:
		class SetKeyOfT
		{
		public:
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator iterator;
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;

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

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

		const iterator begin() const
		{
			return _t.begin();
		}

		const iterator end() const
		{
			return _t.end();
		}

		pair<iterator, bool> insert(const K& key)
		{
			pair<typename RBTree<K, K, SetKeyOfT>::iterator, bool> ret = _t.Insert(key);
			return pair<iterator, bool>(ret.first, ret.second);
		}

	private:
		RBTree<K, K, SetKeyOfT> _t;
	};
}

模拟实现map

#pragma once
#include"RBTree.h"

namespace yzk
{
	template<class K, class V >
	class map
	{
		class MapKeyOfT
		{
		public:
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;

		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}

		const_iterator begin() const
		{
			return _t.begin();
		}

		const_iterator end() const
		{
			return _t.end();
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert(make_pair(key, V()));
			return ret.first->second;
		}

		pair<iterator, bool> insert(const pair<K, V>& kv)
		{
			return _t.Insert(kv);
		}
	private:
		RBTree<K, pair<const K, V>, MapKeyOfT> _t;
	};
}
Raymood_
关注
  • 22
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
map与set的底层大概框架-红黑树
04-04
学习map和set的友友们如果对红黑树的底层框架很模糊。 可以借鉴一下本文件中的红黑树。 虽然有些地方写的不够全不够好， 但是基本的迭代器功能都已经实现。其实红黑树的学习主要就是学习它的插入， 最重要的就是...
数据结构之红黑树详解
12-31
在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。它是复杂的，但它的操作有着良好的最坏情况运行...
C++——map&&set&&红黑树
2302_78794424的博客
05-19 885
1. set是按照一定次序存储元素的容器(升序2. 在set中，元素的value也标识它(value就是key，类型为T)，每个value必须是唯一的(去重set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。3. set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭代。4.set在底层是用红黑树实现的。
【c++】map和set&&AVL树&&红黑树详解&&模拟实现&&map和set封装
m0_74722801的博客
05-21 917
【c++】map和set&&AVL树&&红黑树详解&&模拟实现&&map和set封装
C++实现红黑树 && 模拟实现set，map
qq_53558968的博客
08-14 517
文章目录前言红黑树的调整 前言 红黑树是一棵平衡二叉搜索树，它的“平衡”虽不及AVLTree，但是它的效率跟AVLTree差不多。而STL中的map和set底层就是封装了一棵红黑树。 红黑树的调整
【c++底层结构】AVL树&红黑树
qq_63051355的博客
07-29 246
/该节点的左孩子 AVLTreeNode < K , V > * _right;//该节点的右孩子 AVLTreeNode < K , V > * _parent;//该节点的父结点 pair < K , V > _kv;//该节点的左孩子 int _bf;
详解set/map的底层结构——AVL树和红黑树
zcxmjw的博客
05-12 1001
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。AVL树的规则如下1.它的左右子树都是AVL树2.左右子树高度之差(这里我们简称为平衡因子)的绝对值不超过1如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在logN，搜索时间复杂度logN。
二叉搜索树-AVL树 & 红黑树
weixin_59901173的博客
03-31 741
map/multimap/set/multiset这几个容器有个共同点是：其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
【C++基础系列】Map&Set容器
Lampard的博客
11-18 172
【C++基础系列】Map容器 大家好，我是Lampard~~ 欢迎来到C++基础系列的博客 今天和大家讲解一下C++里面常见的Map容器。 map面试题 Map常见用法 ...
Java学数据结构（3）——树Tree & B树 & 红黑树 & Java标准库中的集合Set与映射Map & 使用多个映射Map的案例
Arya的博客，专注后端领域
08-26 729
1.B树，阶M，数据树叶上，根的儿子数在2和M之间，除根外，非树叶节点儿子为M/2和M之间； 2.B树的插入引起分裂，B树的删除，引起合并和领养； 3.红黑树，根是黑的，红色节点的儿子必须是黑的，所有路径的黑色节点数相同； 4.红黑树的插入，颜色翻转，单旋转，插入节点定颜色； 5.java标准库的set和map，使用红黑树；
从2-3树理解红黑树
02-25
在实际应用中，红黑树被广泛应用于各种数据结构，如C++标准模板库（STL）中的map和set，以及Java中的TreeMap和 TreeSet。这些数据结构的底层实现都依赖于红黑树的高效性能。 总结来说，2-3树和红黑树是数据结构中的...
红黑树-基于C语言实现的红黑树数据结构.zip
03-21
在实际应用中，红黑树广泛用于各种场景，如C++标准库中的STL map和set，它们底层就是基于红黑树实现的。红黑树的高效性和自平衡特性使得它在内存管理、数据库索引、文件系统等领域都有重要应用。理解并熟练掌握红黑...
红黑树实现源码
07-22
红黑树因其高效性能在许多实际应用中得到采用，如C++标准模板库(STL)中的set和map容器，以及Java的TreeMap和TreeSet类。它们使用红黑树作为底层数据结构，提供快速的查找、插入和删除操作。 5. 红黑树的优势： - ...
c++习题08-计算星期几
码到成龚的博客
07-03 561
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
C++初学者指南-3.自定义类型(第一部分)-析构函数
silencestarsky的博客
07-02 607
本文介绍了C++初学者指南中关于自定义类型和析构函数的重要内容。主要涵盖了特殊的成员函数如构造函数和析构函数的作用，RAII资源管理的重要性以及避免编写特殊成员函数的建议。
【C语言】19.预处理详解
hlyd520的博客
07-02 1279
C语言设置了一些预定义符号，可以直接使用，预定义符号也是在预处理期间处理的。__FILE__ //进行编译的源文件__LINE__ //文件当前的行号__DATE__ //文件被编译的日期__TIME__ //文件被编译的时间__STDC__ //如果编译器遵循ANSI C，其值为1，否则未定义这行代码会报错，说明VS没有完全遵循ANSIC这个标准return 0;return 0;
Android 开发中 C++ 和Java 日志调试
最新发布
小羊子的技术专栏
07-04 855
Android 开发中 C++ 和Java 日志调试方法小结
map和set的底层为什么使用红黑树，而不使用AVL树
03-25
map和set使用红黑树的主要原因是红黑树的平衡性能相对较好且实现比较简单，而AVL树的平衡性能更好但实现相对较为复杂。在实际使用中，红黑树的优越性能已经足够满足大部分的需求，因此STL中的map和set选择了红黑树...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值