C++进阶：红黑树介绍及模拟实现(图示详解过程)

最新推荐文章于 2024-06-15 10:30:23 发布
最新推荐文章于 2024-06-15 10:30:23 发布
阅读量1k 收藏 14
点赞数 13
分类专栏： c++学习 文章标签： c++ java 开发语言 linux 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74415153/article/details/138874675
版权

C++进阶：红黑树介绍及模拟实现

上次介绍了AVL树：C++进阶：AVL树详解及模拟实现（图示讲解旋转过程）

今天就来紧接着来红黑树啦!!!

文章目录

1.红黑树介绍

红黑树是一种自平衡的二叉搜索树，它在每个节点上增加了一个表示颜色的存储位，可以是红色（Red）或黑色（Black）。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的从而保证了查找、插入和删除操作的时间复杂度为 O ( l o g N ) O(logN) O(logN)

约束规则

  1. 每个结点是红色或者黑色

  2. 根节点是黑色

  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的（不能有连续的红节点）

  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点

  5. 叶子节点（NIL节点）是黑色的(此处的叶子结点指的是空结点)

RB1

2.项目文件规划

RB2

头文件RBTree.h：进行模拟的编写

源文件test.cpp：进行测试，检查代码逻辑是否满足期望

3.整体框架（节点和Tree）

enum Colour//使用枚举来定义，后面模拟哈希时也会用到类似的
{
	RED,
	BLACK
};

template<class K,class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;//左节点
	RBTreeNode<K, V>* _right;//右节点
	RBTreeNode<K, V>* _parent;//父亲节点
	Colour _col;//颜色，红和黑嘛
	pair<K,V> _kv;//节点里存pair

	RBTreeNode(const pair<K, V>& kv)//都直接在初始化列表里初始化了
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(RED)//这里新插入的节点一定要是红色，黑色的话会直接破坏规则
	{}
};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;//名字太长了，叫Node也更好理解
public:


private:
	Node* _root = nullptr;//给上缺省值
};

4.RBL树的新节点插入

基本步骤：

  1. 查找插入位置： 首先，我们需要找到新节点应该插入的位置。从根节点开始，按照二叉搜索树的性质，逐级向左或向右比较键值，直到找到一个合适的位置。

  2. 插入新节点： 找到插入位置后，我们创建一个新的节点，颜色为红，并将其插入到树中。如果树为空，则新节点成为树的根节点。否则，将新节点插入到合适的位置，使得树仍然保持二叉搜索树的性质。

  3. 插入后有需要变化时情况很多，下面具体分析

因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点，此时需要对红黑树分情况来讨论：

如果新插入节点的父亲节点是黑，那根本不会违反规则，如果要调整只有如下情况：

RB3

bool Insert(const pair<K,V> kv)
	{
		if (_root == nullptr)//如果为空，直接更换新节点
		{
			_root = new Node(kv);
			_root->_col = BLACK;//注意默认是红，这里改成黑
			return true;
		}

		Node* parent = nullptr;//存一下，新根才能链接
		Node* cur = _root;
		while (cur)//开始找插入位置
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;//不能有相等的
			}
		}

		cur = new Node(kv); //这是默认红色的
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;//新节点链接成功了

		while (parent != nullptr 
			&& parent->_col == RED)//父亲节点存在且是红进来，黑的直接满足不用调整
		{
			//这里进行处理
		}
		_root->_col = BLACK;//最后直接改根节点，不用再具体考虑
		return true;
	}

4.1 叔叔节点存在且为红

以下步骤来调整：

  1. 将父节点和叔叔节点都改为黑色。
  2. 将祖父节点改为红色。
  3. 将当前节点指向祖父节点，并将祖父节点设为当前节点的父节点(开始向上走)。

RB4

4.2 叔叔节点不存在

如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点则cur和p一定有一个节点的颜色是黑色，就不满足性质4: 每条路径黑色节点个数相同。

RB5

  1. p为g的左孩子，cur为p的左孩子，则进行右单旋转

p为g的右孩子，cur为p的右孩子，则进行左单旋转

  1. p、g变色—>p变黑，g变红
void RotateL(Node* parent)//左旋
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		subR->_left = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = subR;

		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subR;
			}
			else
			{
				ppnode->_right = subR;
			}
			subR->_parent = ppnode;
		}
	}

	void RotateR(Node* parent)//右旋
	{
		++rotateSize;

		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		subL->_right = parent;

		Node* ppnode = parent->_parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}
	}

4.3叔叔节点存在而且为黑（单旋情况，左子树的左，和右子树的右）

如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的现在看到其是红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色

RB6

4.4叔叔节点存在而且为黑（双旋情况，左子树的右，和右子树的左）

p为g的左孩子，cur为p的右孩子，左右双旋+变色
p为g的右孩子，cur为p的左孩子，右左双旋 +变色

4.5完整版Insert（）

bool Insert(const pair<K,V> kv)
	{
		if (_root == nullptr)//如果为空，直接更换新节点
		{
			_root = new Node(kv);
			_root->_col = BLACK;//注意默认是红，这里改成黑
			return true;
		}

		Node* parent = nullptr;//存一下，新根才能链接
		Node* cur = _root;
		while (cur)//开始找插入位置
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;//不能有相等的
			}
		}

		cur = new Node(kv); //这是默认红色的
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;//新节点链接成功了

		while (parent != nullptr 
			&& parent->_col == RED)//父亲节点存在且是红进来，黑的直接满足不用调整
		{
			Node* grandfather = parent->_parent;
			//接下来分两种：parent是grandfather左或者右
			if (parent == grandfather->_left)//左
			{
				Node* uncle = grandfather->_right;
				//情况一：叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					//先变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					//继续往上走
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况二：叔叔不存在或者存在且为黑
				{
					if (cur == parent->_left)//cur在parent左，单旋
					{
						//       g
						//    p    u
						// c
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else//cur在parent右，双旋
					{
						//       g
						//    p     u
						//      c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
				}
				//情况二一旦旋转完了，不用向上了
				break;
			}
			else//parent是grandfather右
			{
				Node* uncle = grandfather->_left;
				// 情况一：叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else// 情况二：叔叔不存在或者存在且为黑
				{
					// 旋转+变色
					//      g
					//   u     p
					//            c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//		g
						//   u     p
						//      c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
				}
				break;
			}
		}
		_root->_col = BLACK;//最后直接改根节点，不用再具体考虑
		return true;
	}

5.中序方便过会测试

	void InOrder()
	{
		_InOrder(_root);
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_kv.first<< endl;
		_InOrder(root->_right);
	}

6.编写函数看是否满足要求

就从规定出发：

  1. 根节点不是黑的不满足
  2. 不是每条路径的黑色节点数量都相同
  3. 存在连续的红节点了

这些都是不满足要求

	bool IsBalance()
	{
		if (_root->_col == RED)
		{
			return false;
		}
		//这里我们先算一条路径的黑色节点数量，作为参考
		int ref = 0;
		Node* cur = _root;
		while (cur)
		{
			if(cur->_col==BLACK)
				ref++;
			cur = cur->_left;//就求最左路径
		}
		return Check(_root, 0, ref);
	}

	bool Check(Node* cur, int blackNum, int ref)
	{
		if (cur == nullptr)//==nullptr 说明一条路径走完了
		{
			if (blackNum != ref)
			{
				cout << "黑色节点的数量不相等" << endl;
				return false;
			}
			return true;
		}

		//这里开始检查没有连续的红，就看每个cur节点和他的父亲就行
				if (cur->_col == RED && cur->_parent->_col == RED)
		{
			cout << cur->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}

		if (cur->_col == BLACK)
		{
			blackNum++;
		}

		return Check(cur->_left, blackNum, refBlackNum)
			&& Check(cur->_right, blackNum, refBlackNum);//递归进去找
	}

IsBalance() 函数首先检查根节点的颜色是否为红色，如果是，则不满足红黑树的性质。然后，通过调用 Check() 函数来递归检查每个节点，确保在每条路径上没有连续的红色节点，并统计路径上的黑色节点数量，最后与参考值进行比较。

Check() 函数中，递归遍历每个节点，并检查其颜色。如果当前节点为红色，并且其父节点也为红色，则说明存在连续的红色节点，不满足红黑树的性质。如果当前节点为黑色，则增加黑色节点计数器。递归地对当前节点的左右子节点进行检查，直到遍历完整棵树的所有路径。

通过这样的检查，我们可以验证红黑树是否满足性质，从而确认树的平衡性。

7.测试

void TestRBTree1()
{
	int a[] = { 4, 2, 6, 1, 3, 5, 15};
	RBTree<int, int> t;
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
	}
	t.InOrder();
	cout << t.IsBalance() << endl;
}

RB7

8.全部代码

8.1 RBTree.h

#pragma once

enum Colour//使用枚举来定义，后面模拟哈希时也会用到类似的
{
	RED,
	BLACK
};

template<class K,class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;//左节点
	RBTreeNode<K, V>* _right;//右节点
	RBTreeNode<K, V>* _parent;//父亲节点
	Colour _col;//颜色，红和黑嘛
	pair<K,V> _kv;//节点里存pair

	RBTreeNode(const pair<K, V>& kv)//都直接在初始化列表里初始化了
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(RED)//这里新插入的节点一定要是红色，黑色的话会直接破坏规则
	{}
};

template<class K, class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;//名字太长了，叫Node也更好理解
public:
	bool Insert(const pair<K,V> kv)
	{
		if (_root == nullptr)//如果为空，直接更换新节点
		{
			_root = new Node(kv);
			_root->_col = BLACK;//注意默认是红，这里改成黑
			return true;
		}

		Node* parent = nullptr;//存一下，新根才能链接
		Node* cur = _root;
		while (cur)//开始找插入位置
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;//不能有相等的
			}
		}

		cur = new Node(kv); //这是默认红色的
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;//新节点链接成功了

		while (parent != nullptr 
			&& parent->_col == RED)//父亲节点存在且是红进来，黑的直接满足不用调整
		{
			Node* grandfather = parent->_parent;
			//接下来分两种：parent是grandfather左或者右
			if (parent == grandfather->_left)//左
			{
				Node* uncle = grandfather->_right;
				//情况一：叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					//先变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					//继续往上走
					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况二：叔叔不存在或者存在且为黑
				{
					if (cur == parent->_left)//cur在parent左，单旋
					{
						//       g
						//    p    u
						// c
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else//cur在parent右，双旋
					{
						//       g
						//    p     u
						//      c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
				}
				//情况二一旦旋转完了，不用向上了
				break;
			}
			else//parent是grandfather右
			{
				Node* uncle = grandfather->_left;
				// 情况一：叔叔存在且为红
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent;
				}
				else// 情况二：叔叔不存在或者存在且为黑
				{
					// 旋转+变色
					//      g
					//   u     p
					//            c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//		g
						//   u     p
						//      c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
				}
				break;
			}
		}
		_root->_col = BLACK;//最后直接改根节点，不用再具体考虑
		return true;
	}
	void RotateL(Node* parent)//左旋
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		subR->_left = parent;
		Node* ppnode = parent->_parent;
		parent->_parent = subR;

		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subR;
			}
			else
			{
				ppnode->_right = subR;
			}
			subR->_parent = ppnode;
		}
	}

	void RotateR(Node* parent)//右旋
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		subL->_right = parent;

		Node* ppnode = parent->_parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = subL;
			}
			else
			{
				ppnode->_right = subL;
			}
			subL->_parent = ppnode;
		}
	}

	void InOrder()
	{
		_InOrder(_root);
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_kv.first<< endl;
		_InOrder(root->_right);
	}

	bool IsBalance()
	{
		if (_root->_col == RED)
		{
			return false;
		}
		//这里我们先算一条路径的黑色节点数量，作为参考
		int ref = 0;
		Node* cur = _root;
		while (cur)
		{
			if(cur->_col==BLACK)
				ref++;
			cur = cur->_left;//就求最左路径
		}
		return Check(_root, 0, ref);
	}

	bool Check(Node* cur, int blackNum, int ref)
	{
		if (cur == nullptr)//==nullptr 说明一条路径走完了
		{
			if (blackNum != ref)
			{
				cout << "黑色节点的数量不相等" << endl;
				return false;
			}
			return true;
		}

		//这里开始检查没有连续的红，就看每个cur节点和他的父亲就行
		if (cur->_col == RED && cur->_parent->_col == RED)
		{
			cout << cur->_kv.first << "存在连续的红色节点" << endl;
			return false;
		}

		if (cur->_col == BLACK)
		{
			blackNum++;
		}

		return Check(cur->_left, blackNum, ref)
			&& Check(cur->_right, blackNum, ref);//递归进去找
	}

private:
	Node* _root = nullptr;//给上缺省值
};

void TestRBTree1()
{
	int a[] = { 4, 2, 6, 1, 3, 5, 15};
	RBTree<int, int> t;
	for (auto e : a)
	{
		t.Insert(make_pair(e, e));
	}
	t.InOrder();
	cout << t.IsBalance() << endl;
}

8.2 test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

#include"RBTree.h"

int main()
{
	TestRBTree1();
	return 0;
}

今天就到这里啦！！

是Nero哦
关注
  • 13
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
rbtrees:红黑树的旧 C++ 实现
07-14
树红黑树的旧 C++ 实现线程安全红黑树的 C++ 实现，不使用 STL，完全没有外部依赖。 该实现是通用且高效的。 插入 100 万个 int32_t 键节点需要 521 毫秒，而从 100 万个节点树中检索需要 2 毫秒！！ 编译，签出并...
红黑树-基于C++实现的红黑树数据结构.zip
03-21
红黑树 红黑树_基于C++实现的红黑树数据结构
C++进阶：AVL树详解及模拟实现（图示讲解旋转过程）
qq_74415153的博客
05-13 791
之前在搜索二叉树最后早就埋下伏笔，来介绍AVL树和红黑树，今天就先来第一个吧
【C++】详解红黑树并模拟实现
ZZZCCC的博客
09-08 280
我们还是沿用AVL树节点的三叉链定义方法，颜色我们用枚举来实现：ps：这里一开始结点定义为红色的原因，我们在后文插入的时候会详细讲解。
详解红黑树，图文并茂
qq_52906742的博客
08-22 2340
树中每个节点的包含五个属性：color，left，right，parent和data。这里的left，right和parent都是节点类型的指针，构成的三叉链结构。和AVL树是一样的。如果一个节点没有子节点或者父节点，则该节点相应属性的值为NIL。我们把这些NIL视为指向二叉搜索树的叶节点的指针(外部节点)，而把带关键字的节点视为树的内部节点。这个NIL在我们下面的讲述中没有多大作用，简单了解就行。红黑树是每个节点都带有颜色属性的二叉查找树，颜色为红色或黑色。节点是红色或黑色。根节点是黑色。
AVL树的介绍与模拟实现（insert+旋转调平精美图示超详解哦）
weixin_73450183的博客
02-02 1099
AVL树在满足二叉搜索树条件的基础上，给每个结点中增加了一个平衡因子（这个平衡因子的值是该结点左右子树的高度差）。AVL树要求平衡因子的绝对值小于等于1，即任意一个结点左右子树的高度差不超过1。通过降低树的高度，从而达到减少平均搜索时间的效果（在这里做例子的平衡二叉树是按照大小次序依次插入的结果）
红黑树介绍与模拟实现（insert+颜色调整精美图示超详解哦）
weixin_73450183的博客
04-04 1647
红黑树是平衡二叉树的一种，他在满足二叉搜索树特性的基础上，给每个结点增加了一个颜色属性，包括Red与Black；并要求从根节点到一个叶子结点形成的任意一条路径中，通过对结点颜色的限制规则，没有任何一条路径回比其他的路径长一倍
算法导论——红黑树插入算法C++实现
xiaowang627的博客
05-07 6245
红黑树图文详解及其C++语言实现
红黑树详解[C++]
EQUINOX1的博客
08-08 55
我们这里直接实现KV模型的红黑树，为了方便后序的旋转操作，将红黑树的结点定义为三叉链结构对于节点颜色，我们选择使用枚举类来控制，一方面增加了代码可读性，另一方面相对于枚举类型，枚举类不会造成命名污染RED, BLACK{}在这里我们可以使用枚举来定义结点的颜色，这样可以增加代码的可读性和可维护性，并且便于后序的调试操作。RED, BLACK问：为什么构造结点时，默认将结点的颜色设置为红色？
C++ 红黑树
异样旧日的博客
06-20 295
红黑树的介绍以及C++实现其插入算法，图文详解
红黑树增删操作详解
m0_48134027的博客
07-11 677
网上众多关于红黑树的讲解，但大多数都是重复的，只列出了几种简单情况，逻辑和思维深度都不足以解答吾之困惑。。。直到看到张彦峰先生的对红黑树的认识总结，基本可以说是集大成者，本文会基于此文章对复杂操作的思路方面做更详细的叙述和逻辑修正，但基本知识会略讲，可以参考原文或其它文章，原文中相关内容图片代码会直接引用，相信本文可以让你彻底弄懂RBTree的增删操作原理。
C++简单实现红黑树的插入
06-06
C++简单实现红黑树的插入
C++红黑树实现过程
09-15
用C++实现的红黑树，没有BUG ，稍微改改就能直接运行了，最优的代码了，拿去研究吧，也没什么可以说的了···
使用C++实现的rbtree红黑树.zip
03-21
红黑树 使用C++实现的rbtree红黑树
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1007
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 144
BCSP-X 11题 C++代码详解
【c++进阶(三)】STL之vector的介绍和使用
最新发布
weixin_62196764的博客
06-15 688
1.vector表示的是可变序列大小的容器2、vector就像数组一样，也采用的连续空间来存储元素，这也意味着可以采用下标对vector的元素进行访问。3、vector与普通数组不同的是，vector的大小是可以动态改变的。4、当vector需要重新分配大小时，其做法是，分配一个新的数组，然后将全部元素移到这个数组当中，并释放原来的数组空间。---这就表明原来指向该位置的迭代器已经失效了，所以在插入和删除数据的时候要返回一个合法的迭代器的位置。
LeetCode 算法：轮转数组c++
小金牛来了
06-09 680
LeetCode 算法：轮转数组c++
c++stl中红黑树的实现
09-14
在C++ STL中，红黑树的实现被封装在`std::map`和`std::set`这两个容器类中。这两个容器类都是基于红黑树实现的，它们提供了高效的查找、插入和删除操作，保证了元素的有序性。 STL中的红黑树实现与你提供的C++代码...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

是Nero哦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值