红黑树的插入与删除

最新推荐文章于 2024-08-08 17:03:13 发布
最新推荐文章于 2024-08-08 17:03:13 发布
阅读量119 收藏
点赞数
文章标签： 数据结构 算法 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41802229/article/details/103846998
版权

红黑树的性质

  1.  节点是红色或黑色

  2.  根是黑色

  3.  所有叶子都是黑色(叶子是NIL节点)

  4.  每个红色节点必须有两个黑色的子节点。（从每个叶子到根的所有路径上不能有两个连续的红色节点。）

  5.  从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。

首先是红黑树的插入
插入首先和二叉树插入一样，只是新节点的颜色一定要设置成红色，还要新节点的父节点属性要指向父节点；
插入以后，此时该树不一定是平衡的，要根据父亲和叔叔节点的颜色进行判断，处理，使它达到平衡；
下图代表不同的情况对应不同的处理
在这里插入图片描述其中主要是通过左旋和右旋来使树达到平衡；
以下是我对此进行的封装

// 左旋
	private void leftTurn(Node upNode, Node downNode) {
		Node dowm_left=downNode.leftChild;
		if (upNode.parentNode != null) {
			grandFather = upNode.parentNode;
			if (grandFather.leftChild == upNode) {
				grandFather.leftChild = downNode;
				downNode.parentNode = grandFather;

			}
			if (grandFather.rightChild == upNode) {
				grandFather.rightChild = downNode;
				downNode.parentNode = grandFather;
			}

		} else {
			downNode.parentNode = null;
			root = downNode;
		}
		if(dowm_left!=null){
			upNode.rightChild=dowm_left;
		}
		downNode.leftChild = upNode;
		upNode.parentNode = downNode;
		upNode.rightChild = null;
		System.out.println("左旋");

	}

	// 右旋
	private void rightTurn(Node upNode, Node dowmNode) {
        Node down_right=dowmNode.rightChild;
		dowmNode.rightChild = upNode;

		if (upNode.parentNode != null) {// 当grandFather不是root节点时；
			dowmNode.parentNode = upNode.parentNode;
			if (upNode.parentNode.leftChild == upNode) {
				upNode.parentNode.leftChild = dowmNode;
			} else {
				upNode.parentNode.rightChild = dowmNode;
			}

		} else {
			dowmNode.parentNode = null;
			this.root = dowmNode;
		}
         if(down_right!=null){
        	 upNode.leftChild=down_right;
         }
		upNode.parentNode = dowmNode;
		upNode.leftChild = null;

		System.out.println("右旋");
	}

然后是删除
删除比插入更复杂
首先共有三种情形
1.无子节点时，删除节点可能为红色或者黑色；
1.1 如果为红色，直接删除即可，不会影响黑色节点的数量；
1.2 如果为黑色，则需要进行删除平衡的操作了；
2.只有一个子节点时，删除节点只能是黑色，其子节点为红色，否则无法满足红 黑树的性质了。 此时用删除节点的子节点接到父节点，且将子节点颜色涂黑，保证黑色数量。
3.有两个子节点时，与二叉搜索树一样，使用后继节点作为替换的删除节点，情形转至为1或2处理。

其实情形3和情形2 最终都要转换成情形1
情形3和2 都要找到一个替代节点，即数值大小最接近于要删除的节点，这个替代节点最终是一个叶子节点，变成了情形1；所以主要的操作就是针对情形1；
如果删除节点是红色叶子节点，则直接删除；以下主要是针对黑色叶子节点；
下面是找替代节点的代码
如果右节点不为null，后继节点就是右节点的最左节点

private Node findStepNode(Node deleteNode) {
		if (deleteNode.rightChild != null) {
			Node x = deleteNode.rightChild.leftChild;
			if (x != null) {
				while (x.leftChild != null) {
					x = x.leftChild;
				}
				return x;
			} else
				return deleteNode.rightChild;
		} 
		else {
			Node x = deleteNode.leftChild.rightChild;
			if (x != null) {
				while (x.rightChild != null) {
					x = x.rightChild;
				}
				return x;
			} else
				return deleteNode.rightChild;
		}

	}
```![在这里插入图片描述](https://img-blog.csdnimg.cn/2020010521224947.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxODAyMjI5,size_16,color_FFFFFF,t_70)
 该图是针对情形1的讨论
 其中兄子节点为黑代表子节点不存在；

 以下是完整代码

package 红黑树;

public class 红黑树 {
Node root = null;
Node currentNode = null;
Node grandFather = null;

public static void main(String[] args) {
	红黑树 tree = new 红黑树();

	// 
	// 
	// tree.insert(3);
	// tree.insert(2);
	tree.insert(1);
	tree.insert(2); tree.insert(3);tree.insert(4);tree.insert(5);tree.insert(6);
	tree.delete(tree.root.rightChild);
	//System.out.println(tree.root.value);
	// tree.insert(7);tree.insert(8);tree.insert(5);;tree.insert(4);
	// System.out.println(tree.root.value + "_" + tree.root.leftChild.value
	// + "_" + tree.root.rightChild.value);
	 System.out.println(tree.root.rightChild.leftChild.value+tree.root.rightChild.leftChild.color+"+");
	 System.out.println(tree.root.rightChild.rightChild.value+tree.root.rightChild.rightChild.color+"+");
	// System.out.println(tree.root.rightChild.rightChild.leftChild.value+tree.root.rightChild.rightChild.leftChild.color+"+");
	// System.out.println(tree.root.rightChild.rightChild.rightChild.value+tree.root.rightChild.rightChild.rightChild.color);
}

// 删除节点
public void delete(Node deleteNode) {
	//System.out.println("s"+deleteNode.value);
	// 一些不需要特别处理的
	/*
	 * 1.deleteNode为红色节点 2.当只有一个子节点时，deleteNode的颜色是黑色，子节点的颜色是红色；
	 * 否则就要用后继节点代替：最接近目标节点的； 3.后继节点为删除节点的右子节点的最左节点,或者左节点的最右节点；
	 * 然后与目标节点互换位置，即变成了删除叶子节点的情形
	 * 
	 * 情形1：无子节点时，删除节点可能为红色或者黑色； 1.1 如果为红色，直接删除即可，不会影响黑色节点的数量； 1.2
	 * 如果为黑色，则需要进行删除平衡的操作了； 情形2： 只有一个子节点时，删除节点只能是黑色，其子节点为红色，否则无法满足红黑树的性质了。
	 * 此时用删除节点的子节点接到父节点，且将子节点颜色涂黑，保证黑色数量。
	 * 情形3：有两个子节点时，与二叉搜索树一样，使用后继节点作为替换的删除节点，情形转至为1或2处理。
	 */

	Node parNode = deleteNode.parentNode;
	// 情形3 存在两个子节点
	if (deleteNode.leftChild != null && deleteNode.rightChild != null) {
		// 交换两个节点位置；只是交换数值，不改变颜色；此时还是处于平衡；
		Node stepNode = findStepNode(deleteNode);
	
		exchangeNode(deleteNode, stepNode);

		delete(stepNode);
		//此时  stepNode为要删除的点 deleteNode已成为后继节点 不一定是叶子节点 可能有一个 可能没有子节点 转到情形1或2

	}
	// 情形1 无子节点
	else if (deleteNode.leftChild == null && deleteNode.rightChild == null) {
		if (deleteNode.color == "red") {
			if (deleteNode.parentNode.leftChild == deleteNode) {
				deleteNode.parentNode.leftChild = null;
			} else
				deleteNode.parentNode.rightChild = null;
		}
		// 删除节点为黑色，则必存在兄弟节点
		else {
			Node broNode = null;
			System.out.println("ar="+parNode.leftChild.value+"_"+deleteNode.value);

			// 兄在右
			if (parNode.leftChild == deleteNode) {
				broNode = parNode.rightChild;
				Node bro_left = broNode.leftChild;
				Node bro_right = broNode.rightChild;
			

				if (broNode.color == "black") {
					// 当兄无子节点时
					if (bro_left == null && bro_right == null) {
						if (parNode.color == "red") {
							parNode.color = "black";
							parNode.leftChild=null;

						} else {
							// 兄变红
							parNode.leftChild = null;
							broNode.color = "red";
						}
						// 此时以达到平衡
					}
					// 当兄有子节点时 且子全红或右红左空
					else if (bro_right.color == "red") {

						// 父节点左旋，父 兄交换颜色 右子节点变黑
						right_red(parNode, broNode, bro_right, bro_left);

						// 此时以达到平衡
					}
					// 左子节点为红，右为空时
					else if (bro_left.color == "red" && bro_right == null) {
						// 兄右旋，交换颜色 跳到上个if 右子节点为红
						rightTurn(broNode, bro_left);
						bro_left.color = "black";
						broNode.color = "red";
						right_red(parNode, bro_left, bro_right, broNode);
					} 
					
				}
				//当兄为红色
				else{
                 //兄红 兄在父右边	
					leftTurn(parNode, broNode);
					
					broNode.color="black";
					
					parNode.color = "black";
					bro_left.color="red";
					parNode.leftChild=null;
					
				}
			} 
			//兄在左边
			else {
				broNode = parNode.leftChild;
				Node bro_left = broNode.leftChild;
				Node bro_right = broNode.rightChild;
				if (broNode.color == "black") {
					// 当兄无子节点时
					if (bro_left == null && bro_right == null) {
						if (parNode.color == "red") {
							parNode.color = "black";
							parNode.leftChild=null;

						} else {
							// 兄变红
							parNode.leftChild = null;
							broNode.color = "red";
						}
						// 此时以达到平衡
					}
					// 当兄有子节点时 且子全红或左红右空
					else if (bro_right.color == "red") {

						// 父节点右旋，父 兄交换颜色 左子节点变黑
						right_red2(parNode, broNode, bro_right, bro_left);

						// 此时以达到平衡
					}
					// 右子节点为红，左为空时
					else if (bro_right.color == "red" && bro_left == null) {
						// 兄左旋，交换颜色 跳到上个if 右子节点为红
						leftTurn(broNode, bro_right);
						bro_right.color = "black";
						broNode.color = "red";
						right_red2(parNode, bro_right, null, broNode);
					} 
				}
				//当兄为红色
				else{
                 //兄红 兄在父左边	
					rightTurn(parNode, broNode);
					
					broNode.color="black";
					
					parNode.color = "black";
					bro_right.color="red";
					parNode.rightChild=null;
					
				}
			}

		}
	}
	// 情形2 有一个子节点 若 当前为黑，子为红，交换颜色即可，否则 寻找后继节点，直到后继结点无子节点 转到情形1
	else {
		// deleteNode一定为黑色
		Node left = deleteNode.leftChild;
		Node right = deleteNode.rightChild;
		if (left != null && left.color == "red") {
			exchangeNode(deleteNode, left);
			deleteNode.color = "black";
			deleteNode.leftChild=null;
		} else if (right != null && right.color == "red") {
			exchangeNode(deleteNode, right);
			deleteNode.color = "black";
			deleteNode.rightChild=null;
		}
		// 子为黑色时，寻找后继节点，递归
		else {
			delete(deleteNode);
		}

	}
}

private void right_red2(Node parNode, Node broNode, Node bro_right, Node bro_left) {
	rightTurn(parNode, broNode);
	broNode.color = "red";
	parNode.color = "black";
	bro_left.color = "black";
	// 左右节点全为红时
		if (bro_right != null && bro_right.color == "red") {
				parNode.leftChild = bro_right;
				bro_right.parentNode = parNode;
		}
			parNode.rightChild = null;
}

private void right_red(Node parNode, Node broNode, Node bro_right, Node bro_left) {
	leftTurn(parNode, broNode);
	broNode.color = "red";
	parNode.color = "black";
	bro_right.color = "black";
	// 左右节点全为红时
	if (bro_left != null && bro_left.color == "red") {
		parNode.rightChild = bro_left;
		bro_left.parentNode = parNode;
	}
	parNode.leftChild = null;

}

private void exchangeNode(Node deleteNode, Node stepNode) {


	int t = stepNode.value;
	stepNode.value = deleteNode.value;
	deleteNode.value = t;
	
}

private Node findStepNode(Node deleteNode) {
	if (deleteNode.rightChild != null) {
		Node x = deleteNode.rightChild.leftChild;
		if (x != null) {
			while (x.leftChild != null) {
				x = x.leftChild;
			}
			return x;
		} else
			return deleteNode.rightChild;
	} 
	else {
		Node x = deleteNode.leftChild.rightChild;
		if (x != null) {
			while (x.rightChild != null) {
				x = x.rightChild;
			}
			return x;
		} else
			return deleteNode.rightChild;
	}

}

// 新增节点
public void insert(Integer value) {
	Node newNode = new Node();
	newNode.color = "red";
	newNode.value = value;

	if (root == null) {
		root = newNode;
		root.color = "black";
		currentNode = root;
	} else {
		addNewNode(newNode, this.root);
		currentNode = newNode.parentNode;
		adjust(newNode);
	}
}

private void adjust(Node newNode) {

	// 当父节点为黑色时，不需另外处理；
	if (currentNode != null && currentNode.color == "black") {
		//System.out.println("当父节点为黑色时，不需另外处理；");
		currentNode = newNode;
	}

	// 当父节点为红色；
	else {
		//System.out.println("当父节点为红色时");
		Node granNode1 = currentNode.parentNode;
		//System.out.println("ff=" + granNode1.value);
		Node uncleNode = null;
		if (granNode1.leftChild == currentNode && granNode1.rightChild != null)
			uncleNode = granNode1.rightChild;
		else if (granNode1.rightChild == currentNode && granNode1.leftChild != null)
			uncleNode = granNode1.leftChild;
		
		
			// 当父节点为红色，叔叔节点也为红色时；
			if (uncleNode != null && uncleNode.color == "red") {
				//System.out.println("uncle=" + uncleNode.color);
				// 当grandFather为root时，父和叔都变黑 祖不变
				//System.out.println("祖父节点的父节点为null时");

				if (granNode1.parentNode == null) {
					currentNode.color = "black";
					uncleNode.color = "black";

				}
				// 不为root时，父和叔都变黑，祖变红；
				else {
				//	System.out.println("祖父节点不为root");
					granNode1.color = "red";
					uncleNode.color = "black";
					currentNode.color = "black";
					newNode = granNode1;
					adjust(newNode);

				}
			}
			// 当父节点为红色，叔叔节点为黑色,或者为空时；
			else {

				//System.out.println("当父节点为红色，叔叔节点为黑色,或者为空时");
				// 当父节点在祖父节点的左边left
				if (granNode1.leftChild == currentNode) {
					// 新节点在父节点右边 right时 新节点与父节点左旋,变色 父节点与祖父节点 右旋
					if (currentNode.rightChild != null && newNode.value == currentNode.rightChild.value) {

						leftTurn(currentNode, newNode);
						// newNode与currentNode的位置已换；
						granNode1.color = "red";
						newNode.color = "black";
						//System.out.println("pop=" + currentNode.color + "_" + newNode.color);
						rightTurn(granNode1, newNode);
					}
					// 当 新节点在父节点左边时，变色(父变黑，祖变红)，再父节点与祖父节点 右旋；
					else {
						granNode1.color = "red";
						currentNode.color = "black";
						rightTurn(granNode1, currentNode);
					}

				}
				// 当父节点在祖父节点的右边right
				else {
					// 当 新节点在父节点左边时，新节点与父节点右旋,变色 父节点与祖父节点 左旋
					if (currentNode.leftChild != null && newNode.value == currentNode.leftChild.value) {

						rightTurn(currentNode, newNode);
						currentNode.color = "black";
						newNode.color = "red";
						leftTurn(granNode1, currentNode);
					}

					// 新节点在父节点右边 right时;变色(父变黑，祖变红)，再父节点与祖父节点 左旋
					else {
						currentNode.color = "black";
						granNode1.color = "red";
						leftTurn(granNode1, currentNode);
					}
				}

			}
		
	}
}

// 根据newNode的大小，将新节点置于当前节点的左边或者右边；
private void addNewNode(Node newNode, Node node) {
	if (newNode.value <= node.value) {
		if (node.leftChild != null) {
			addNewNode(newNode, node.leftChild);
			//System.out.println("gggggggggggg");
		} else {
			node.leftChild = newNode;
			newNode.parentNode = node;
			System.out.println(newNode.value + "加在" + node.value + "左边");
		}
	} else {
		if (node.rightChild != null) {
			addNewNode(newNode, node.rightChild);
			//System.out.println("gggggggggggg");
		} else {
			node.rightChild = newNode;
			newNode.parentNode = node;
			System.out.println(newNode.value + "加在" + node.value + "右边");
		}
	}

}

// 左旋
private void leftTurn(Node upNode, Node downNode) {
	Node dowm_left=downNode.leftChild;
	if (upNode.parentNode != null) {
		grandFather = upNode.parentNode;
		if (grandFather.leftChild == upNode) {
			grandFather.leftChild = downNode;
			downNode.parentNode = grandFather;

		}
		if (grandFather.rightChild == upNode) {
			grandFather.rightChild = downNode;
			downNode.parentNode = grandFather;
		}

	} else {
		downNode.parentNode = null;
		root = downNode;
	}
	if(dowm_left!=null){
		upNode.rightChild=dowm_left;
	}
	downNode.leftChild = upNode;
	upNode.parentNode = downNode;
	upNode.rightChild = null;
	System.out.println("左旋");

}

// 右旋
private void rightTurn(Node upNode, Node dowmNode) {
    Node down_right=dowmNode.rightChild;
	dowmNode.rightChild = upNode;

	if (upNode.parentNode != null) {// 当grandFather不是root节点时；
		dowmNode.parentNode = upNode.parentNode;
		if (upNode.parentNode.leftChild == upNode) {
			upNode.parentNode.leftChild = dowmNode;
		} else {
			upNode.parentNode.rightChild = dowmNode;
		}

	} else {
		dowmNode.parentNode = null;
		this.root = dowmNode;
	}
     if(down_right!=null){
    	 upNode.leftChild=down_right;
     }
	upNode.parentNode = dowmNode;
	upNode.leftChild = null;

	System.out.println("右旋");
}

class Node {

	Node parentNode;
	Node leftChild;
	Node rightChild;
	Integer value;
	String color;
}

}
tx、、///、、潇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
红黑树及其插入、删除操作
程序人生
10-19 2158
在二叉搜索树中，基本操作如结点的插入、删除、查找的性能上界都得不到保证，原因在于二叉搜索树的构造依赖于其结点值的插入顺序，最坏情况下二叉搜索树会退化为单链表（如下图所示）。因此我们需要对二叉搜索树做出一些改进和限制，从而使其拥有更好更稳定的性能上界保证。红黑树就是一种自平衡的二叉搜索树。 定义 红黑树除了满足二叉搜索树的性质以外，还有以下性质： （1）红黑树的结点都是带有“颜色”属性的，...
算法7-红黑树的插入与删除
起舞的日子
04-12 161
读者盆友，晚上好。 本博客代码示例均来自：算法 Algorithmes Forth Edition [美] Robert Sedgewick Kevin Wayne 著 谢路云译 前几篇博客顺序的介绍了符号表的各种实现： 我们首先介绍了：无序链表中顺序查找 -》 有序数组中的二分查找 二分查找优缺点： 二分查找 优点 缺点 查找非常快，已知的最快的方法，复杂度在log N 静...
【数据结构】红黑树的插入(Insert)
zangyuanan320的博客
06-16 1318
红黑树的情况分析，以及插入写法
红黑树插入、删除、查找算法学习
雨纷飞
11-11 5138
红黑树(red-black tree)是许多“平衡”搜索树中的一种，可以保证在最坏情况下基本动态集合操作的时间复杂度为O(lgn)，文章讲述红黑树的性质，结构描述，插入、删除算法分析，最后完成一个C语言测试程序。
【C++】红黑树插入删除
fight_p的博客
12-14 1321
这是一篇关于红黑树插入删除为主要内容的文章，本文详细讲述了红黑树的插入情形以及如何解决，代码如何实现，当然最重要的就是红黑树的删除，虽然红黑树删除不简单，但是删除的无非就是叶子节点，一个孩子的节点，两个孩子的节点，被删节点是红色还是黑色。其中最重要的就是删除的黑色叶子节点这有些麻烦，其他的都很简单！本文把每个情况都详细罗列出来。其实看完之后红黑树的删除真的没有那么难！！！
红黑树的插入和删除
Djsnxbjans的博客
06-10 1532
红黑树简述 红黑树的概念 红黑树的性质 红黑树结点定义 一，红黑树的插入 插入调整 插入代码 二，红黑树的验证 三，红黑树的删除 待删除的结点只有一个子树 删除结点颜色为红色 删除结点颜色为黑色 删除的结点为叶子节点 删除结点颜色为红色 删除结点颜色为黑色 红黑树删除代码 四，红黑树与AVL树的比较
红黑树插入与删除
10-11
主要讲述红黑树的插入、查找、删除、并设计了测试程序去测试程序的正确性
红黑树插入与删除.xmind
03-26
红黑树的插入与删除各种情况，内容更正了之前版本的错误
红黑树插入删除伪算法
03-10
在"红黑树插入删除伪算法（含图示）"文件中，你将能看到具体的操作流程和变化过程，这对于理解红黑树的内部工作机制非常有帮助。 总的来说，红黑树是一种高效的数据结构，广泛应用于数据库系统、编译器、虚拟机等...
红黑树插入删除算法
09-27
红黑树插入删除算法，算法导论上算法，可以运行
红黑树的插入与删除说明
04-15
通过对红黑树插入和删除操作的深入理解，我们可以更好地利用这种数据结构来优化算法性能。无论是插入还是删除操作，都需要仔细考虑节点的颜色和位置关系，以确保树的平衡性和红黑树性质的维持。通过适当的旋转和颜色...
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 412
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
数据结构——排序（2）：选择排序+交换排序
最新发布
2301_81888634的博客
08-08 807
在快速排序中，找基准数的函数有多种实现方法，我们下期见~敬请期待“数据结构——排序（3）”~
【深度学习】P1 深度学习数据结构
weixin_43098506的博客
08-07 788
深度学习的数据结构——张量的概念与其基本操作
【数据结构】栈篇
2303_79015671的博客
08-07 1049
手把手教你实现栈~
【数据结构】五、树：2.二叉树（完全二叉树、前中后序遍历）
来csdn只办三件事：开源！开源！还是***开源！
08-07 624
1.1斜树 1.2满二叉树 ❗1.3完全二叉树 1.4排序二叉树BST 1.5平衡二叉树AVL 1.6线索二叉树 2.性质 3.存储结构 3.1顺序存储 3.2链式存储 4.遍历 4.1前序遍历 4.1.1前序非递归方式 4.2中序遍历 4.2.1中序非递归方式 4.3后序遍历 4.3.1后序非递归方式 4.4递归求树的深度 4.5层序遍历 4.6由遍历序列构造二叉树
重生之我 学习【数据结构之顺序表（SeqList）】
xupy019的博客
08-06 1061
全新的开始，为大家带来数据结构的内容（C语言实现）将以顺序表、链表、栈区、队列、二叉树、常见排序算法为主要内容展开学习
白骑士的Matlab教学基础篇 1.2 MATLAB基础语法
JeremyTC的博客
08-07 997
在本节中，我们将介绍 MATLAB 的命令窗口和脚本文件功能。这些工具使 MATLAB 成为一个强大而灵活的计算和编程环境。了解如何使用命令窗口和脚本文件可以帮助用户快速进行计算、编写和运行复杂的程序。
红黑树插入删除详解：规则与操作推导
在这个详细的整理文档中，我们将探讨红黑树插入和删除操作的关键步骤以及旋转原则。 1. 插入操作: - 插入过程与普通二叉搜索树相同，首先将新节点标记为红色。 - 从新插入的节点开始，向上调整颜色，确保满足红黑...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值