RBTree的删除

最新推荐文章于 2024-07-19 13:59:11 发布
最新推荐文章于 2024-07-19 13:59:11 发布
阅读量543 收藏 2
点赞数 3
分类专栏： C++ 数据结构与算法 文章标签： 红黑树 删除 规则 节点释放 路径平衡
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55439426/article/details/126699686
版权

文章目录

前言：

  • 博主收集的资料New Young，连载中。

  • 博主收录的问题:New Young

  • 转载请标明出处：New Young

  • 本文的RBTree是有问题的，向祖先寻求帮助时，uncle为红色的情况代码不会实现，留给以后吧！

红黑树的构成规则

红黑是在二叉搜索树的基础上，添加一些规则的一种高效的数据结构

  1. 根节点是黑色

这里的根节点是整体这个树的根，不是左右子树的根

  1. 我们空节点是黑色的，称为NIL节点

  2. 如果一个节点是红色的，那么它的左右孩子必须是黑色的

特别的，左右孩子是2个NIL节点也可以

  1. 从根到每一个NILL节点的所有路径中，黑色节点个数必须一样

  • 记住路径最终的尽头是NIL节点，这个是解决红黑树删除的关键。

  • 该规则保证了，红黑树中最长路径不超过最短路径的2倍。

证明:

设所有路径中，相同的黑色节点个数为N。

最短路径可能是：全部是黑色节点

由规则3，一但路径中出现红色节点，那么它的下一个节点必然是黑色的。

最坏的情况是：一红一黑交叉出现，那么N个黑色节点，最多这条路径上是2*N-1个节点。

因此说：红黑树中最长路径不超过最短路径的2倍

红黑树的删除

虽然看到删除，你可能会认为删除后的修复情况非常多，其实可能是你对RBTree的规则未理解好的原因，RBTree的删除情况的修复其实不多，那么让我们开始学习它！

关键

  1. 直到NIL才算是路径，因此在每种情形中一定要保证到NIL的黑色节点数不变。这种保证，可以通过不用的红色节点变成黑色节点辅助，也可以通过让树的2端同时减少相同的黑色节点，整体是缺失，就借助树的祖先，重复上述黄色字体过程。
  2. **默认用替代法中的向左找最大值分析问题**
  3. 节点的释放时机要提前，否则通过祖先的帮助平衡RBTree的循环就会出问题如野指针问题，逻辑问题

思路

由删除使用的替代法可以知道，如果我们找到了那个替代节点X，那么X一定至少有一个孩子是NIL节点，如果不是这样，说明我们未正确找到替代节点。

接上面。

情形一：如果X是红色的，

由规则3,4它的左右孩子一定都为NIL节点。

处理方式：直接删除即可，红色节点不影响路径中黑色节点个数

在这里插入图片描述

情形二：X是黑色的

由规则3,4，它一定存在uncle，否则左右子树的NIL的黑色节点不平衡。至于uncle什么颜色，分析即可

（1）它如果X存在孩子，那一定是一个没有孩子的红色节点。

处理：删除X，让红色孩子变黑。
在这里插入图片描述

（2）X没有孩子，删除X后，左子树缺失一个黑色节点。那么我们可以尝试能否借助uncle中的红色节点，通过旋转，让左子树这边多一黑色节点，左右子树仍是平衡。

  1. uncle是红色的，那么它的父亲一定是黑色的，且一定存在2个黑色的左右孩子，且左右孩子没有孩子。

    处理：uncle在右边，uncle右旋后，父亲左旋，交换uncel和UR的颜色

    uncle在左边，uncle左旋后，父亲右旋，交换uncel和UL的颜色

在这里插入图片描述

  1. uncle是黑色时，由规则3,4，如果uncle存在孩子一定为红色。通过旋转让红色节点上来。
    • 存在红色孩子时

处理：

本质上是让红色节点代替父亲节点，让父亲节点变成黑色节点就可以达到左右树黑色节点平衡。

uncle在右边时

  1. 红色孩子在左边，uncle向右旋，parent左旋，UL着父亲颜色，父亲变黑。
  2. 红色孩子在右边，parent左旋，uncle着父亲颜色，父亲变黑，UR变黑

uncle在左边时

红色孩子在左边，parent右旋，uncke着父亲颜色，父亲变黑，UL变黑

  1. 红色孩子在右边，uncle左旋，uncle右旋，UR着父亲颜色，父亲变黑

在这里插入图片描述

  • 不存在孩子时—是最复杂的情形。

1. 此时无论什么方式，都不能通过uncle来让左右子树平衡，父亲也不行，因此我们只能让uncle边红，让左右勉强达到平衡，但是整个树仍是缺失一个黑色节点，因此我们要向祖先寻求帮助，通过祖先的红色节点边黑色节点，来辅助平衡。这种通过祖先帮助，最坏到root，但是因为我们让uncle变红了，我们让root这个树整体所有路径都少一个黑色节点，整体还是平衡的。

​

在这里插入图片描述

节点释放的时机！！！！

最后一种树整体缺失x个黑色节点的情形，如果父亲仍是黑色，我们仍按照上述情形处理就会出问题，因此我们在进入循环前就要释放节点X，这个释放只有一次，之后对X的孩子进行分析。

这样情形就如下：----可能描述的不是很清楚，需要自己看博主的代码逻辑才能很好理解。

情形一：如果孩子为红

孩子变黑即可

情形二：孩子为空且X为红

这个要在进入循环前就处理，因为可能通过祖先节点的方式，平衡RBTree。

情形三：孩子为空且X为黑或者孩子为黑

  1. uncle为黑且存在红色节点
>   **通过双旋或者单旋**
  1. uncle为空或者uncel为黑且uncke没有节点
>**uncle变红，进入下一层循环**
  1. uncle为红，
>   **父亲进行单旋**

X为红代码

if (cur->_color == RED)
			{
				//如果为红色，那么左右孩子一定为空
				Node* parent = cur->_parent;
				if (parent)
				{

					if (parent->_left == cur)
					{
						parent->_left = nullptr;
					}
					else
					{
						parent->_right = nullptr;
					}
				}
				else
				{
					cout << "该树不是红黑树" << endl;
					assert(false);
				}
				delete cur;
				return true;
			}

x为黑代码

if (cur->_color == BLOCK)
				//如果cur存在孩子，那它一定为红，且红色孩子没有左右孩子
				//父亲可能存在，可能不存在
			{
				//要提前保证删除cur
				Node* parent = cur->_parent;
				Node* child = cur->_left;
				if(cur->_right)
					child = cur->_right;
				if (parent)
				{
					if (parent->_left == cur)
					{
						parent->_left = child;
					}
					else
					{
						parent->_right = child;
					}
				}
				else//说明删除的是根
				{
					if (child)//child存在就置黑
					{
						child->_color = BLOCK;
					}
					_root = child;
					delete cur;
					return true;
				}
				delete cur;//删除节点
				cur = nullptr;
				while (parent)
				{
					//第一次的parent不可能为空,为空程序是不会走到这里
					//因为可能出现借助祖先节点的情况，
					//child可红或者黑
					if (child&&child->_color==RED)
						//存在为红,直接将child变为黑色，
						      //不影响路径黑色节点个数
					{
						child->_color = BLOCK;
						break;
					}
					else  if(child==nullptr||(child && child->_color == BLOCK))
						//child为nullptr或者child为黑，就看uncle了
					{
						//uncle一定存在，否则删除前就不是红黑树,因为如果不存在，
						// 则删除那边的的路径上就多一个黑色节点
						//1. uncle为红，uncle与父亲交换颜色，父亲变为黑色
						//2. uncle为黑,
						// 那么它要么没孩子节点，这时候直接将uncle变为黑色，通过祖先节点，再找一个黑色节点
						// 要么它只能有一红色孩子节点，通过单旋/双旋将红色节点旋转到缺失的一边，变为黑色即可
						//   
						Node* uncle = parent->_right;
						if (child== parent->_right)
							uncle = parent->_left;
						if (uncle)
						{
							Node* UL = uncle->_left;
							Node* UR = uncle->_right;
							if (uncle == parent->_right)
							{
								if (uncle->_color == BLOCK)
								{
									if (UL && UL->_color == RED)
									{
										_reloveR(uncle);
										_reloveL(parent);
										UL->_color = parent->_color;
										parent->_color = BLOCK;
										break;
									}
									else if (UR && UR->_color == RED)
									{
										_reloveL(parent);
										uncle->_color = parent->_color;
										parent->_color = BLOCK;
										UR->_color = BLOCK;
										break;
									}
									else
									{
										uncle->_color = RED;
										child = parent;
										parent = parent->_parent;
									}
								}
								else
									//uncle为红色，父亲一定为黑，那么它必定有2个黑色孩子
									///双旋，之后交换uncle和UL的颜色
								{
									_reloveR(uncle);
									_reloveL(parent);
								swap(uncle->_color, UR->_color);
									break;

								}

							}
							else if (uncle == parent->_left)
							{

								if (uncle->_color == BLOCK)
								{

									if (UL && UL->_color == RED)
									{
										_reloveR(parent);
										uncle->_color = parent->_color;
										parent->_color = BLOCK;
										UL->_color = BLOCK;
										break;
									}
									else if (UR && UR->_color == RED)
									{
										_reloveL(uncle);
										_reloveR(parent);
										UR->_color = parent->_color;
										parent->_color = BLOCK;
										break;
									}
									else
									{
										uncle->_color = RED;
										child = parent;
										parent = parent->_parent;
									}
								}
								else
									//uncle为红色，则父亲一定为黑色，那么它必定有2个黑色孩子
								//双旋，之后交换uncle和UL的颜色
								{
									_reloveL(uncle);
									_reloveR(parent);
								swap(uncle->_color, UL->_color);
									break;

								}
							}
						}
						//uncle不可能不存在
						//
						else{
							assert(false);
						}
					}
					else
					{
					assert(false);
					}

				}
			}

Swap代码

	void Swap(Node* root1, Node* root2)
	{
		assert(root1);
		assert(root2);
		//root1默认是要删除的节点，且root2的左右孩子必定为空
		Node* parent1 = root1->_parent;
		Node* parent2 = root2->_parent;
		if (parent1)
		{
			//先处理父亲节点
			if (root1 == parent1->_left)
			{
				parent1->_left = root2;
			}
			else
			{
				parent1->_right = root2;
			}
		}
		else
		{
			_root = root2;
		}

		if (root2 == parent2->_left)
		{
			parent2->_left = root1;
		}
		else
		{
			parent2->_right = root1;
		}
		std::swap(root1->_parent, root2->_parent);
		std::swap(root1->_left, root2->_left);
		//交换后root1的左孩子为空
		//调整左右孩子指向
		if (root2->_left)
			root2->_left->_parent = root2;
		std::swap(root1->_right, root2->_right);
		//交换后root1的右孩子为空
		//调整左右孩子指向
		if (root2->_right)
			root2->_right->_parent = root2;
		//交
		std::swap(root1->_color, root2->_color);
	}

全部代码

bool Erase(const T&data)
	{
		//定位节点
		Node* cur = _root;
		while (cur)
		{
			if (kot()(cur->_data) > kot()(data))
			{
				cur = cur->_left;
			}
			else if (kot()(cur->_data) < kot()(data))
			{
				cur = cur->_right;
			}
			else
			{
				break;
			}
		}
		if (cur == nullptr)
		{
			cout << "RBT中不存在以" << kot()(data) << "为key的节点" << endl;
			return false;
		}
		else
		{
			Node* del = cur;
			//替代法
			//那边存在，就向那边替代
			if (cur->_right)
			{
				//向右找最小
				Node* min = cur->_right;//max一定存在且不为空
				while (min->_left)
				{
					min = min->_left;
				}
				this->Swap(cur, min);
			}
			else if (cur->_left)
			{
				//向左找最大
				Node* max = cur->_left;//max一定存在且不为空
				while (max->_right)
				{
					max = max->_right;
				}
				this->Swap(cur, max);
			}
			else//当成无孩子的节点，正常走流程
			{
				;
				
			}
			//定位的节点，至少有一边为nullptr
			//走到这里说明，cur一定存在孩子节点且一定存在父亲节点

			//情形一：
			//红色，一定有父亲节点，否则就不为红色，
			//父亲节点一定为黑，因此只需要链接好与父亲节点即可
			if (cur->_color == RED)
			{
				//如果为红色，那么左右孩子一定为空
				Node* parent = cur->_parent;
				if (parent)
				{

					if (parent->_left == cur)
					{
						parent->_left = nullptr;
					}
					else
					{
						parent->_right = nullptr;
					}
				}
				else
				{
					cout << "该树不是红黑树" << endl;
					assert(false);
				}
				delete cur;
				return true;
			}
			else if (cur->_color == BLOCK)
				//如果cur存在孩子，那它一定为红，且红色孩子没有左右孩子
				//父亲可能存在，可能不存在
			{
				//要提前保证删除cur
				Node* parent = cur->_parent;
				Node* child = cur->_left;
				if(cur->_right)
					child = cur->_right;
				if (parent)
				{
					if (parent->_left == cur)
					{
						parent->_left = child;
					}
					else
					{
						parent->_right = child;
					}
				}
				else//说明删除的是根
				{
					if (child)//child存在就置黑
					{
						child->_color = BLOCK;
					}
					_root = child;
					delete cur;
					return true;
				}
				delete cur;//删除节点
				cur = nullptr;
				while (parent)
				{
					//第一次的parent不可能为空,为空程序是不会走到这里
					//因为可能出现借助祖先节点的情况，
					//child可红或者黑
					if (child&&child->_color==RED)
						//存在为红,直接将child变为黑色，
						      //不影响路径黑色节点个数
					{
						child->_color = BLOCK;
						break;
					}
					else  if(child==nullptr||(child && child->_color == BLOCK))
						//child为nullptr或者child为黑，就看uncle了
					{
						//uncle一定存在，否则删除前就不是红黑树,因为如果不存在，
						// 则删除那边的的路径上就多一个黑色节点
						//1. uncle为红，uncle与父亲交换颜色，父亲变为黑色
						//2. uncle为黑,
						// 那么它要么没孩子节点，这时候直接将uncle变为黑色，通过祖先节点，再找一个黑色节点
						// 要么它只能有一红色孩子节点，通过单旋/双旋将红色节点旋转到缺失的一边，变为黑色即可
						//   
						Node* uncle = parent->_right;
						if (child== parent->_right)
							uncle = parent->_left;
						if (uncle)
						{
							Node* UL = uncle->_left;
							Node* UR = uncle->_right;
							if (uncle == parent->_right)
							{
								if (uncle->_color == BLOCK)
								{
									if (UL && UL->_color == RED)
									{
										_reloveR(uncle);
										_reloveL(parent);
										UL->_color = parent->_color;
										parent->_color = BLOCK;
										break;
									}
									else if (UR && UR->_color == RED)
									{
										_reloveL(parent);
										uncle->_color = parent->_color;
										parent->_color = BLOCK;
										UR->_color = BLOCK;
										break;
									}
									else
									{
										uncle->_color = RED;
										child = parent;
										parent = parent->_parent;
									}
								}
								else
									//uncle为红色，父亲一定为黑，那么它必定有2个黑色孩子
									///双旋，之后交换uncle和UL的颜色
								{
									_reloveR(uncle);
									_reloveL(parent);
								swap(uncle->_color, UR->_color);
									break;

								}

							}
							else if (uncle == parent->_left)
							{

								if (uncle->_color == BLOCK)
								{

									if (UL && UL->_color == RED)
									{
										_reloveR(parent);
										uncle->_color = parent->_color;
										parent->_color = BLOCK;
										UL->_color = BLOCK;
										break;
									}
									else if (UR && UR->_color == RED)
									{
										_reloveL(uncle);
										_reloveR(parent);
										UR->_color = parent->_color;
										parent->_color = BLOCK;
										break;
									}
									else
									{
										uncle->_color = RED;
										child = parent;
										parent = parent->_parent;
									}
								}
								else
									//uncle为红色，则父亲一定为黑色，那么它必定有2个黑色孩子
								//双旋，之后交换uncle和UL的颜色
								{
									_reloveL(uncle);
									_reloveR(parent);
								swap(uncle->_color, UL->_color);
									break;

								}
							}
						}
						//uncle不可能不存在
						//
						else{
							assert(false);
						}
					}
					else
					{
					assert(false);
					}

				}
			}	
			return true;
		}	
	}

随机插入测试

void MapT()
	{
		srand(time(0));
		int N = 15;//截图有限
		vector<int> v;
		for (int i = 0; i < N; ++i)
		{
			v.push_back(rand() % 20);
		}
		NY::Map<int, int > map;
		for (auto e : v)
		{
			map.Insert(make_pair(e,e));
		}
		if (map.IsRBTree())
			cout << "True" << endl;
		else
			cout << "False" << endl;
		for (int i = 0; i < N; ++i)
		{
			cout << "删除 ("<<v[i]<<v[i]<<")前:" ;

			map.Inorder();
			cout << endl;
			map.Erase(v[i]);
			cout << "删除后:";
			map.Inorder();
			cout << endl;
			cout << "##################################" << endl;
		}
	}

在这里插入图片描述

总结

如果熟悉了红黑树的规则，细致分析就不用担心红黑色的删除的情形。AVl的删除也是。
工作中一般更多的是关注RBTree的删除思想

New Young
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
STL源码剖析---红黑树原理详解
flyingleo1981的专栏
07-27 4812
一、红黑树概述      红黑树和我们以前学过的AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。不过自从红黑树出来后，AVL树就被放到了博物馆里，据说是红黑树有更好的效率，更高的统计性能。这一点在我们了解了红黑树的实现原理后，就会有更加深切的体会。      红黑树和AVL树的区别在于它使用颜色来标识结点的高度，它所追求的是局部平衡而不是AVL
RBtree详解之删除(含完整红黑树代码)
sowhat
04-09 1万+
前面我们讨论了红黑树的插入的实现，基本思想是分类讨论；然后分情况讨论以后我们发现插入操作调整函数只需要处理三种情况，并不是太复杂。但是 删除操作会更复杂一点，因为二叉搜索树的删除操作本身就分成了多种情况，这样在执行删除操作后要处理的情况会更多；下面对于删除操作我们仍旧采 取分类讨论的方法，将所有的情况梳理清楚后，就可以理解红黑树的删除调整函数的实质了。  下面先放出红黑树删除函数的代码：
红黑树添加删除节点操作详解资料整理.doc
01-09
stl源码剖析一书中关于红黑树删除的操作只字未提，删除操作比较复杂，没有相关说明比较晦涩。 本人再看这个函数时也是冒了一身冷汗，这方面的资料很匮乏，好容易找到了，与大家分享一下。。。
RB树(红黑树)插入以及删除
ProgramVAE的博客
07-25 1484
红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 它是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑树”。 红黑树和AVL树类
RBTree（Insert & Delete)
Case
03-20 1339
　　这个红黑树想了很久，特别在做删除时候，搞不懂《算法导论》里面那个ｘ是什么东西，最后想了很久，最终才知道那个ｘ原来是删除后的节点的候补节点，ｙ是被删除的节点，我在做这个程序的时候可能跟《算法导论》的处理有点不同，它里面的ＮＵＬＬ节点与我的处理好象不一样（反正我看得不是很懂) ，我对于那个NULL节点，是在deletefixup里面new两个新的节点，不断的通过检测是否为空，来将其赋值，然后在每次
【数据结构三】RBTree红黑树代码测试, 添加 ,删除
xbd_zc的博客
03-22 1174
6.5测试类 文章目录6.5测试类添加测试类1`TreeOperation`2添加测试类2`RBTreeTest`3, RBTreeput方法测试运行结果网站验证remove方法测试 (前驱) 添加测试类1TreeOperation package com.ccc.util.treemap; public class TreeOperation { /* 树的结构示例： 1 / \ 2 3
RBtree插入跟删除图解代码
热门推荐
sowhat
04-09 2万+
一、红黑树的简介 红黑树是一种平衡的二叉查找树，是一种计算机科学中常用的数据结构，最典型的应用是实现数据的关联，例如map等数据结构的实现。 红黑树有以下限制： 1. 节点必须是红色或者是黑色 2. 根节点是黑色的 3. 所有的叶子节点是黑色的。 4. 每个红色节点的两个子节点是黑色的，也就是不能存在父子两个节点全是红色 5. 从任意每个节点到其每个叶子节
红黑树rbTree.c
05-12
红黑树的遍历，查找过程，以及插入时对红黑树进行位置修复，修复包括左旋右旋，还有就是红黑树节点的删除，删除之后还要对节点修复
RBTree-Program.rar_RBtree
09-19
红黑树（Red-Black Tree，简称RBTree）是一种自平衡二叉查找树，由Rudolf Bayer在1972年提出。这种数据结构在现代计算机科学中有着广泛的应用，尤其是在操作系统、数据库系统和各种编程语言的标准库中。红黑树的名字...
rbtree_ubuntu_kenerl5.2.2.rar
07-28
`rbtree.h`则包含了红黑树的相关宏定义和声明，例如插入、删除、遍历等操作的接口。 `rbtree.txt`文件可能详细介绍了红黑树在内核中的具体应用，如何使用这些接口，以及在特定场景下优化的策略。它也可能包含了一些...
rbtree2.zip
06-13
在Linux系统中，红黑树（Red-Black Tree，简称RBTree）是一种自平衡二叉查找树，它具有良好的性能特性，被广泛应用于各种数据结构和算法实现中，如内核中的内存管理、文件系统等。红黑树的名字来源于其节点颜色属性...
使用C语言实现的rbtree红黑树.zip
03-21
3. 删除操作：删除节点时，需要考虑多种情况，如删除的节点是红色、黑色、有两个子节点、一个子节点或者没有子节点。通常会用到替换节点、颜色翻转和旋转等技术。 4. 查找操作：红黑树的查找与普通二叉查找树类似，...
RBTree
Liudengdeng_的博客
04-18 980
红黑树保证最长路径不超过最短路径的2倍，因而近似平衡1、每个节点，不是红色就是黑色2、根节点是黑色3、如果一个节点是红色的，则他的两个子节点是黑色的（没有连续的红节点）4、每条路径上黑色节点数量相等5、每个叶子节点都是黑的（这里的叶子节点指的是空节点）当新插入节点是红色的，其父亲也是红色的，那么就知道了祖父是黑色的，所以叔叔的颜色比较重要第一种：cur为红，p为红，g为黑,u存在且为红，则将p,u...
rbtree search, insert, delete
weixin_30364325的博客
04-23 74
#include <stdio.h>#include <stdlib.h>#include <time.h>#include <assert.h>#include <assert.h>#include <string.h>enum { BLACK, RED};enum { LEFT, RIGHT};ty...
C语言实现红黑树，详解红黑树旋转，插入删除问题
weixin_42209544的博客
09-09 317
c语言实现红黑树，对于红黑树旋转，插入删除问题进行梳理
linux内核+红黑树删除,关于linux:Linux内核红黑树原理概括
weixin_29564301的博客
04-30 111
二叉查找树因为在频繁的动静更新过程中，可能会呈现树的高度远大于 log2n的状况，所以就会导致各个操作效率降落，最坏的状况下就会进化为链表，变为O(n)．很显著，想要解决这个问题，无效的一种方法就是使得树的高度不要差很多，也就是均衡它。最先创造的均衡二叉查找树是AVL树，(它严格合乎均衡二叉查找树的定义，即任何节点的左右子树高度相差不超过 1，是一种高度均衡的二叉查找树。)然而在工程中，咱们常常听...
ngx_rbtree的基本使用方法
magic的博客
08-06 1881
ngx_rbtree 导语： 红黑树是一个常用的高级数据结构，它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的:它可以在O(log n)时间内做查找，插入和删除，这里的n是树中元素的数目. 一： 红黑树的性质 1. 每个节点不是红的就是黑的 （必须上色嘛） 2. 根节点必须是黑的 3. 每个叶节点是黑色的（ngx 是sentinel） 4. 如果该节点是
红黑树（RBTree）之删除结点图解
码不停蹄
11-06 4243
红黑树之删除结点图解
【18】输出字符菱形
最新发布
2301_78786609的博客
07-19 371
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
qwt rbtree
09-13
红黑树（Red-Black Tree）是一种自平衡的二叉搜索树，它在插入和删除操作后通过重新着色和旋转来维护平衡。红黑树的名字来自于节点上的颜色标记，每个节点可以是红色或黑色。 红黑树具有以下特性： 1. 每个节点要么...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值