数据结构与算法学习⑧(自平衡二叉搜索树旋转和实现 手撕红黑树插入与删除)
数据结构与算法学习⑧
- 数据结构与算法学习⑧
-
- 1、AVL树
-
- 1.1、定义及特点
- 1.2、四种失衡及旋转
- 1.3、AVL的实现
- 2、红黑树
-
- 2.1红黑树的定义及特点
- 2.2红黑树的实现-添加
-
- 实现之前讲讲旋转
- 开始实现
- 2.3红黑树的实现-删除
-
- 删除的所有情况
-
- 删除度为1的黑色节点
- 删除度为0的黑色节点
- 删除总结
- 删除代码
数据结构与算法学习⑧
1、AVL树
在前面的课程中，我们学习了二叉搜索树（BST）,它的插入、删除、查找操作时间复杂度在最好情况下才是 O(log n)，不过在二叉查找树频繁的动态更新过程中，会逐渐退化直至最坏的情况变为链表，
时间复杂度退化为O(n)，所以我们要解决这种复杂度退化的问题就要找到一种平衡二叉树，平衡二叉查找树中“平衡”的意思，其实就是让整棵树左右看起来比较“对称”、比较“平衡”，不要出现左子树很高、右子树很矮的情况。这样就能让整棵树的高度相对来说低一些，相应的插入、删除、查找等操作的效率高一些。
在根据输入的数据构建 BST 树时，特别依赖输入数据是否有序，如果输入数据相对有序那产生的树的结构会非常的不平衡，那查询等相关操作的效率会受到影响。
平衡二叉查找树：简称平衡二叉树，发明平衡二叉查找树这类数据结构的初衷是，解决普通二叉查找树在频繁的插入、删除等动态更新的情况下，出现时间复杂度退化的问题。
也就是说这类二叉搜索树在插入，删除操作后，如果树失去了平衡，它能通过一些操作自平衡。常见的有 AVL 树，红黑树等。
1.1、定义及特点
AVL树是最早发明的自平衡二叉搜索树之一，由前苏联的数学家 Adelse-Velskil 和 Landis 在 1962年提出的高度平衡的二叉树，根据科学家的英文名也称为 AVL 树。它的定义如下：
1：它是一棵 BST 树
2：它的每个节点左右子树高度之差（简称平衡因子/Balance Factor）绝对值不超过1
3：可以是空树，如果不是空树，任何一个结点的左子树与右子树都是平衡
二叉树的高度有两种定义：
- 从根节点到最深节点的最长路径的节点数。
- 从根到最深节点的最长路径的边数。
如果采用第一种定义：空树的高度为0，叶子节点的高度为1
如果采用第二种定义：空树的高度为-1，叶子节点的高度为0
两种均可，为了便于理解我们取第一种定义（因为只需要数节点数即可）
图二中：7的左子树是一棵avl树，但是整体并非avl树
AVL树具备以下的一些特点：
1、对于给定结点数为n的AVL树，最大高度为O(log2 n)，也就说，从n个数中，查找一个特定值的时间复杂度是O(log n)。因此，AVL 是一种特别适合进行查找操作的树,，此外在AVL树中插入，删除操作的时间复杂度均为O（n）
2、在平衡二叉树中，当我们插入新元素或删除某元素时，为了保证二叉搜索树的特性，很容易导致某些结点失衡，即该结点的平衡因子大于1，而平衡二叉树的平衡二字体现了它可以自动恢复平衡，这个自动平衡的过程是通过旋转来完成的。
1.2、四种失衡及旋转
在平衡二叉树的插入和删除操作中，某些节点会失去平衡，我们先来看插入的情况，如果A是一颗平衡二叉树，如果新插入一个元素，会有两个结果
- 平衡没有被打破，不用调整
- 平衡被打破，需要调整
对于任意一次插入所造成的不平衡，都可以简化为下列4中情况
情况1-RR：插入节点在失衡节点右子树的右边，我们要对失衡节点进行左旋
图解如下：失衡节点的平衡因子为 -2
情况2-LL：插入节点在失衡节点左子树的左边，我们需要对失衡节点进行右旋
与此同时，我们发现，左旋和右旋操作其实是成镜像关系的。
情况3-LR：插入节点在失衡节点左子树的右边，先对失衡节点的左子树左旋(左子树为RR情况)，再对失衡节点右旋(失衡节点为LL情况)
情况4-RL：插入节点在失衡节点右子树的左边，先对失衡节点右子树右旋（右子树为LL情况），再对失衡节点左旋（失衡节点为RR情况）
总结：
RR左旋失衡结点
LL右旋失衡节点
LR左旋失衡节点的左子树，然后再对失衡节点右旋
RL右旋失衡结点的右子树，然后再对失衡节点左旋
旋转有点像跷跷板，左旋，左边下去了。右旋，右边下去了
1.3、AVL的实现
1、创建AVL树，定义树的节点 AvlNode
public class AvlTree {
AvlNode root;
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("该树的前序遍历结果为:");
preOrder(root,sb);
sb.append("该树的中序遍历结果为:");
inOrder(root,sb);
sb.append("该树的后序遍历结构为:");
postOrder(root,sb);
return sb.toString();
}
private void inOrder(AvlNode node, StringBuilder sb) {
if (node == null) {
return;
}
inOrder(node.left,sb);
sb.append(node.key).append("->");
inOrder(node.right,sb);
}
private void preOrder(AvlNode node, StringBuilder sb) {
if (node == null) {
return;
}
sb.append(node.key).append("->");
preOrder(node.left,sb); preOrder(node.right,sb);
}
private void postOrder(AvlNode node, StringBuilder sb) {
if (node == null) {
return;
}
postOrder(node.left,sb);
postOrder(node.right,sb);
sb.append(node.key).append("->");
}
public static class AvlNode{
int key;
AvlNode left;
AvlNode right;
/*** 我们取第一种高度定义:从根节点到最深节点的最长路径的节点数
* * 故：空树高度记为0，叶子节点高度记为1 */
int height =1; public AvlNode(int key) {
this.key = key; }
}
}
2、定义一个方法用以获取节点的高度
/** 获取节点的高度
* 这里高度的定义是：从根节点到最深节点的最长路径的节点数。
* @param node * @return */
public int getHeight(AvlNode node){
return node == null ? 0 : node.height;// 空树的高度为0
}
3、编写一个函数针对 RR 情况进行旋转 public AvlNode RRrotate(AvlNode unbalance) {
/** * RR旋转:对失衡节点进行左旋 *
* 20 30
* / \ / \
* 10 30 20 40
* / \ --RR旋转- / \ \
* 25 40 10 25 50
* \
* 50
* @param unbalance 失衡节点
* @return 调整后的根节点 */
public AvlNode RRrotate(AvlNode unbalance) {// 20为失衡点
AvlNode root = unbalance.right;//失衡点的右子树的根结点30作为新的根结点
unbalance.right = root.left;//将新的根结点的左子树25成为失衡点20的右子树
root.left = unbalance; // 将失衡点20作为新的根结点的左子树
/**
* 重新设置失衡点20和新节点30的高度 其他节点的高度不变
* 节点高度如何确定？
* 节点的高度= Math.max(左子树的高度,右子树的高度) +1 */
unbalance.height = Math.max(getHeight(unbalance.left),getHeight(unbalance.right)) +1;
root.height = Math.max(getHeight(root.left),getHeight(root.right)) +1;
return root;// 新的根节点取代原失衡点的位置 }
4、编写一个函数针对 LL 情况进行旋转： public AvlNode LLrotate(AvlNode unbalance) {
/** * LL旋转：对失衡节点进行右旋 *
* 30 20
* / \ / \
* 20 40 10 30
* / \ --LL旋转- / / \
*10 25 5 25 40
5、编写两个函数分别针对 LR,RL 两种情况进行旋转
6、编写插入操作，插入操作要注意几点
AVL 树也是一棵 BST 树，插入要符合 BST 树的特征
插入操作涉及到从根节点开始依次进行比较，直到插入。插入完成后要从原路回溯查找失衡节
点，并且进行旋转调整，故相对较好的实现方式是基于递归来完成。
* / * 5 * @param unbalance 失衡节点 * @return 调整后的根节点 */
public AvlNode LLrotate(AvlNode unbalance) { // 30为失衡点
AvlNode root = unbalance.left;//失衡点的左子树的根结点20作为新的根结点
unbalance.left = root.right;//将新的根结点的右子树25成为失衡点30的左子树
root.right = unbalance;// 将失衡点30作为新的根结点的右子树
// 重新设置失衡点30和新节点20的高度
unbalance.height = Math.max(getHeight(unbalance.left),getHeight(unbalance.right)) +1;
root.height = Math.max(getHeight(root.left),getHeight(root.right)) +1;
return root;
}
5、编写两个函数分别针对 LR,RL 两种情况进行旋转
/** *
* LR旋转：先对失衡节点的左子树按RR情况处理，再对失衡节点按LL处理
* * @param unbalance
* * @return */
public AvlNode LRrotate(AvlNode unbalance) {
unbalance.left = RRrotate(unbalance.left); // 先将失衡点的左子树进行RR旋转
return LLrotate(unbalance);// 再将失衡点进行LL平衡旋转并返回新节点代替原失衡点
}
/** * RL旋转：先对失衡节点的右子树按LL情况处理，再对失衡节点按RR情况处理
* @param unbalance
* @return */
public AvlNode RLrotate(AvlNode unbalance) {
unbalance.right = LLrotate(unbalance.right);// 先将失衡点的右子树进行LL平衡 旋转
return RRrotate(unbalance);// 再将失衡点进行RR平衡旋转并返回新节点代替原失衡点
}
6、编写插入操作，插入操作要注意几点
- AVL 树也是一棵 BST 树，插入要符合 BST 树的特征
- 插入操作涉及到从根节点开始依次进行比较，直到插入。插入完成后要从原路回溯查找失衡节
点，并且进行旋转调整，故相对较好的实现方式是基于递归来完成。
public void insert(int key) {
this.root = insert(this.root, key);
}
/**
* 针对一棵二叉搜索树,通过递归的方式去插入
* 同时在回溯的过程中找到失衡节点,判断属于RR,LL,LR,RL中的哪种情况，进行旋转调整，
* 最后插入路线上的每个节点需要重新调整高度
* 7、编写测试代码进行测试：
**/
public AvlNode insert(AvlNode tree, int key) {
//terminal
if (tree == null) {
tree = new AvlNode(key);
return tree;
}
//current logic
/**
* 判断 key是插入到tree的左子树还是右子树
* 回溯的过程中判断该节点是否失衡
* 如果失衡判断属于哪种情况,根据情况进行调整 */
if (key > tree.key) { //插入到右子树
//drill down 插入到右子树
tree.right = insert(tree.right, key);
//判断当前节点tree是否失衡
if (Math.abs(getHeight(tree.left) - getHeight(tree.right)) > 1) {
//判断属于RR 还是RL
if (key > tree.right.key) {
//RR情况
tree = RRrotate(tree);
} else {
//RL情况
tree = RLrotate(tree);
}
}
} else if (key < tree.key) { //插入到左子树
//drill down 插入到左子树
tree.left = insert(tree.left, key);
//判断当前节点tree是否失衡
if (Math.abs(getHeight(tree.left) - getHeight(tree.right)) > 1) {
//判断属于LL,还是LR
if (key < tree.left.key) {
//LL情况
tree = LLrotate(tree);
} else {
//LR情况
tree = LRrotate(tree);
}
}
} else {
//根据情况，不做操作或者更新该节点
}
tree.height = Math.max(getHeight(tree.left),getHeight(tree.right)) +1;
return tree;
}
7、编写测试代码进行测试
比对RR,RL,LR,RL的四张图片测试理解。
public static void main(String[] args) {
//testRR();
// testLL();
// testLR();
// testRL();
}
//测试RR情况
public static void testRR(){
AvlTree avlTree = new AvlTree();
avlTree.insert(1);
avlTree.insert(2);
avlTree.insert(3);
System.out.println(avlTree);
avlTree.insert(4);
avlTree.insert(5);
System.out.println(avlTree);
avlTree.insert(6);
System.out.println(avlTree);
avlTree.insert(7);
avlTree.insert(8);
avlTree.insert(9);
System.out.println(avlTree);
avlTree.insert(10);
}
public static void testLL(){
AvlTree avlTree = new AvlTree();
avlTree.insert(10);
avlTree.insert(9);
avlTree.insert(8);
System.out.println(avlTree);
avlTree.insert(7);
avlTree.insert(6);
System.out.println(avlTree);
avlTree.insert(5);
System.out.println(avlTree);
avlTree.insert(4);
avlTree.insert(3);
avlTree.insert(2);
avlTree.insert(1);
System.out.println(avlTree);
}
public static void testLR(){
AvlTree avlTree = new AvlTree();
avlTree.insert(10);
avlTree.insert(7);
avlTree.insert(9);
System.out.println(avlTree);
avlTree.insert(2);
avlTree.insert(5);
avlTree.insert(6);
System.out.println(avlTree);
avlTree.insert(3);
avlTree.insert(1);
avlTree.insert(4);
System.out.println(avlTree);
}
public static void testRL(){
AvlTree avlTree = new AvlTree();
avlTree.insert(1);
avlTree.insert(4);
avlTree.insert(2);
System.out.println(avlTree);
avlTree.insert(9);
avlTree.insert(6);
System.out.println(avlTree);
avlTree.insert(5);
System.out.println(avlTree);
avlTree.insert(8);
avlTree.insert(10);
avlTree.insert(7);
System.out.println(avlTree);
}
9、面试实战题目
1382. 将二叉搜索树变平衡
进阶：对于AVL树的查询操作和删除操作应该如何来完成呢？
1、对于查询，AVL树也是一棵BST树，所以查询操作跟BST的查询操作一样，比较简单，复杂
度O(log n)
2、对于删除，删除情况跟BST树一样，只不过删除之后也需要查找失衡节点并进行自平衡操
作。
2、红黑树
2.1红黑树的定义及特点
在前面的章节中我们讲到了AVL树这样一个平衡二叉查找树数据结构，它能够做到插入，删除，查询的时间复杂度为O(log n)，AVL树是一种非常严格的平衡二叉树并且它也是自平衡的，AVL树有很多好处但也有弊端，AVL 树为了维持这种高度的平衡，就要付出更多的代价。每次插入、删除都要做调整，就比较复杂、耗时。所以，对于有频繁的插入、删除操作的数据集合，使用 AVL 树的代价就有点高了。
其实平衡二叉查找树有很多，接下来我们学习一种数据结构叫红黑树，红黑树是一种比较难的数据结构，但是又由于红黑树是一种性能非常稳定的二叉查找树，所以，在工程中，但凡是用到动态插入、删除、查找数据的场景，都可以用到它。红黑树也是为了解决普通二叉查找树在数据更新的过程中，复杂度退化的问题而产生的。
红黑树（Red Black Tree）：也是一种自平衡的二叉搜索树，之前叫做平衡二叉B树（SymmetricBinary B-Tree）。
首先，红黑树也是一棵二叉搜索树 BST ，因此它也满足 BST 树的所有特征。除此之外，它必须满足
以下5条性质：
- 性质1：节点具备颜色，要么是红色（RED）,要么是黑色（BLACK）。
- 性质2：根节点是黑色（BLACK）。
- 性质3：叶子节点都是黑色（BLACK）的空节点，也不存数据。
注意：
1、红黑树中的叶子节点并非我们之前所讲的叶子节点，红黑树中的叶子节点是假想出来的，是为了配合它的一些性质而产生的（在java中就是为null的空节点）。
2、红黑树这样定义叶子节点，会让原来度为0及度为1的节点都变成度为2的节点。另外：在后续讲解过程中，我们将叶子节点省略，但要认识到它的存在！ - 性质4：红黑树中，红色（RED）节点的子节点都是黑色（BLACK）
注意：由红黑树的这一性质可推导出两个结论
1、红色节点的父节点都是黑色
2、从根节点到叶子节点的所有路径上不能有2个连续的红色（RED）节点 - 性质5：从任一节点到叶子节点的所有路径都包含相同数目的黑色（BLACK）节点
总之：在这些规则的约束下，红黑树能够保证平衡。
这不是一颗红黑树,性质3的关系,每个节点都伸出两个叶子节点null,38这个节点右拉出个叶子节点(假想),从叶子节点出发,只有3个黑色节点,而其他的都是4个节点,所以违反了性质5
2.2红黑树的实现-添加
实现之前讲讲旋转
新添加的节点应该是什么颜色?
第一类:有4种情况
父节点为黑色：此时仍然满足红黑树的所有性质，无需处理
第二类:有8种情况
父节点为红色 , 违反了性质4，出现Double Red，我们需要针对这8种情况进行调整
判断条件：叔父节点不是红色(这句是重点,叔父不是红色说明右边或者左边缺失了，也就是不平衡得情况，需要旋转来维持平衡)
修复性质4-RR/LL
RR
父节点为红色
38->46->50->52
因为52插入导致违反了性质4,插入默认为红色,需要的操作是:
父节点染黑,祖父节点染红,也就是说50染黑,46染红,46左旋操作,
LL
80->76->72->60
因为60插入导致违反了性质4,
父节点染黑,祖父节点染红,72黑76红,76右旋操作
1、染色：自己染成黑色， 祖父节点染成红色
判断条件：叔父节点不是红色（这句是重点,叔父不是红色说明右边或者左边缺失了，也就是不平衡得情况，需要旋转来维持平衡）
添加-修复性质4-LR/RL
一样得染色操作
自己变黑，祖父变黑
RL
只是旋转这一块，先右父节点，再左旋祖父节点
LR:父节点左旋，祖父右旋
RL:父节点右旋，祖父左旋
修复性质4-LL/RR/LR/RL
判断条件：叔父节点是红色（叔父是红色节点说明是平衡的，只需要染色即可，递归染色）
父节点和叔父节点染成黑色，祖父节点染成红色，这样就红黑红了，递归，最终到根节点，根节点是终止条件染成黑色
注意：
1.父节点为红色，祖父节点是黑色，这个黑色是假象的，脑补出来的null，也就是性质3中的（性质3：叶子节点都是黑色（BLACK）的空节点，也不存数据），这种情况需要RR,LL,RL,LR旋转的，其他只需要染色或者不操作即可
2.这里有别于AVL（自平衡树），自平衡拿失衡节点做操作的，而这个红黑树是根据插入节点操作的。所以需要存父节点
开始实现
先构造一些实用的方法
public class RBTree {
private static final boolean RED = false;
private static final boolean BLACK = true;
Node root;//
//给节点node染色并返回该节点
private Node color(Node node, boolean color) {
if (node == null) {
return node;
}
node.color = color;
return node;
}
//将节点染成红色
public Node red(Node node) {
return color(node, RED);
}
//将节点染成黑色
public Node black(Node node) {
return color(node, BLACK);
}
//返回节点的颜色
public boolean colorOf(Node node) {
return node == null ? BLACK : node.color;
}
//判断是否是黑色
public boolean isBlack(Node node) {
return colorOf(node) == BLACK;
}
//判断是否是红色
public boolean isRed(Node node) {
return colorOf(node) == RED;
}
@Override
public Object root() {
return root;
}
@Override
public Object left(Object node) {
return ((Node) node).left;
}
@Override
public Object right(Object node) {
return ((Node) node).right;
}
@Override
public Object string(Object node) {
return node;
}
public static class Node {
int key;
boolean color = RED;//代表节点的颜色 RED=false BLACK=true
Node left;
Node right;
Node parent;
public Node(int key, Node parent) {
this.key = key;
this.parent = parent;
}
//判断当前节点是否是最后一层的叶子
public boolean isLeaf() {
return left == null && right == null;
}
//判断是否有两个节点
public boolean hasTwoChildren() {
return left != null && right != null;
}
//判断当前节点是否是其父节点的左子节点
public boolean isLeftChild() {
return parent != null && this == parent.left;
}
//判断当前节点是否是其父节点的右子节点
public boolean isRightChild() {
return parent != null && this == parent.right;
}
//获取当前节点的兄弟节点
public Node sibling() {
if (isLeftChild()) {
return parent.right;
}
if (isRightChild()) {
return parent.left;
}
return null;
}
@Override
public String toString() {
String str = "";
if (color == RED) {
str = "R_";
}
return str + key;
}
}
添加
public void add(int key) {
//判断传入元素
//判断root是否为空元素
if (root == null) {
root = new Node(key, null);
afterAdd(root);
return;
}
//找到新节点应插入到哪个位置
Node parent = null;
Node curr = root;
while (curr != null) {
parent = curr;
//插入的元素大了，右
if (key > curr.key) {
curr = curr.right;
} else if (key < curr.key) {
curr = curr.left;
}
}
//完毕之后跑到要添加的节点位置了
Node newNode = new Node(key, parent);
//父节点指针先指向子节点
if (key > parent.key) {
parent.right = newNode;
} else if (key < parent.key) {
parent.left = newNode;
}
afterAdd(newNode);
}
public void afterAdd(Node node) {
Node parent = node.parent;
//判断父节点是否为空，空说明是根节点，染成黑色
if (parent == null) {
black(node);
return;
}
//如果父节点是黑色，那就不用操作了
if (isBlack(parent)) {
return;
}
//如果父节点是红色的话又要分两种情况了（叔父是红色和叔父是黑色）
// 叔父是黑色的话说明不平衡需要旋转，叔父是红色只需要递归染色即可
//拿到叔父节点和祖父节点
Node uncle = parent.sibling();
//祖父节点，后续几个情况都需要祖父节点变成红色，那就先变色吧
Node grand = red(parent.parent);
//如果叔父节点是红色的话，平衡递归染色
if (isRed(uncle)) {
black(uncle);
black(parent);
//染成黑色，递归
afterAdd(grand);
return;
}
//接下来就是LL RR LR RL的情况
//LL RR 父染成黑色，祖父红色，旋转祖父节点
//LR RL自己黑，祖父红
//LR:父节点左旋，祖父右旋 RL:父节点右旋，祖父左旋
if (parent.isLeftChild()) {
if (node.isLeftChild()) {
//左左
black(parent);
// red(grand);
LLroate(grand);
} else {
//LR
black(node);
LRroate(grand);
}
} else {
if (node.isRightChild()) {
//右右
black(parent);
RRroate(grand);
} else {
//RL
black(node);
RLroate(grand);
}
}
}
重点讲一下RR的插入旋转过程
建议截图代码，然后跟着图过，非常有帮助。
private Node RRroate(Node node) {
//RR左旋的操作
Node newParent = node.right;
//newParent的左节点指向node的右节点
node.right = newParent.left;
if (newParent.left != null) {
//newParent的左子树认爸爸，指针相互指对方
newParent.left.parent = node;
}
//node接到newParent上，并且把node的parent让newParent去接，
newParent.left = node;
newParent.parent = node.parent;
//头去判断是放左还是放右
if (node.isLeftChild()) {
node.parent.left = newParent;
} else if (node.isRightChild()) {
node.parent.right = newParent;
} else {
root = newParent;
}
node.parent = newParent;
return newParent;
}
LL情况类似不画图了，建议拿个插入之前的树想过程
private Node LLroate(Node node) {
Node newParent = node.left;
node.left = newParent.right;
if (newParent.right != null) {
newParent.right.parent = node;
}
newParent.right = node;
newParent.parent = node.parent;
if (node.isLeftChild()) {
node.parent.left = newParent;
} else if (node.isRightChild()) {
node.parent.right = newParent;
} else {
root = newParent;
}
node.parent = newParent;
return newParent;
}
LR RL拿子节点转，然后自己转即可
private Node LRroate(Node node) {
RRroate(node.left);
return LLroate(node);
}
private Node RLroate(Node node) {
LLroate(node.right);
return RRroate(node);
}
2.3红黑树的实现-删除
首先，红黑树也是一棵二叉搜索树，对于二叉搜索树的删除，总共可以分为3中情况：
1、删除度为0的节点：直接删除
2、删除度为1的节点：父节点指向其子节点
3、删除度为2的节点：用前驱节点或后继节点替换删除节点，真正被删除的是用以替换的前驱或者后继节点，即回到了前两种情况。
前驱:左子树最大值
后继:右子树最小值
结论:真正被删除的是那些度为0和度为1的节点
删除的所有情况
通过对 BST 树删除情况的分析，红黑树的删除总共有如下几种情况：
删除的节点是红色节点
直接删除
删除的节点是黑色节点
1.拥有一个黑色子节点
2.最后一层黑色叶子节点(这里不是指想象出来的null)
结论:需要针对删除黑色节点的两种情况进行调整,如果只剩根节点直接删除即可
删除度为1的黑色节点
删除度为0的黑色节点
1.如果被删除节点度为0，且是根节点，则直接删除即可，无需做任何调整。
度为0的非根节点
这个时候需要看兄弟节点了
前提
兄弟节点是黑色,并且有红色子节点
被删除节点在左边：父节点RR/RL旋转，旋转后根节点继承父节点颜色，且根节点左右子节点染黑色
注:(二)72的值应改为82
被删除节点在右边:父节点LL/LR旋转，旋转后根节点继承父节点颜色，且根节点左右子节点染黑色
(三)的情况可以看成RL或者RR,建议看成RR,少一次旋转
前提
黑兄弟无红色子节点
没的旋转了,只能染色,父节点是红色的话,会违背性质5,所以向上染色;
父节点是黑色的情况,兄弟染红,父染黑,递归处理.
前提
兄弟节点是红色
需要经过操作后回到兄弟节点是黑色的情况
删除总结
删除代码
public void remove(int key) {
remove(node(key));
}
private Node node(int key) {
//先找到要删除的节点位置
Node node = root;
while (node != null) {
if (node.key > key) {
node = node.left;
} else if (node.key < key) {
node = node.right;
} else {
return node;
}
}
return null;
}
private void remove(Node node) {
if (node == null) {
return;
}
//如果是度2的节点,也就是有两个子孩子
if (node.hasTwoChildren()) {
//可以采用前驱或者后继节点来代替被删除节点
//这里采用前驱
Node p = node.left;
while (p.right != null) {
p = p.right;
}
//找到后
node.key = p.key;
//接下来真正要删除的是前驱节点了
node = p;
//删除度为1和度为0的节点node
//找到其代替节点
Node replacement = node.left != null ? node.left : node.right;
//父节点认儿子的过程
if (node.parent == null) {
root = replacement;
//判断左右节点
} else if (node.isLeftChild()) {
node.parent.left = replacement;
} else if (node.isRightChild()) {
node.parent.right = replacement;
}
afterRemove(node, replacement);
node.parent = null;
node.left = null;
node.right = null;
}
}
private void afterRemove(Node beRemoved, Node replacement) {
//如果删除的是红色节点,无需调整
if (isRed(beRemoved)) {
return;
}
//被删除的是黑色节点
//如果被删除节点有一个红色的代替子节点(度为1),染色
if (isRed(replacement)) {
black(replacement);
return;
}
//要删除的是度为0的黑色叶子节点
Node parent = beRemoved.parent;
if (parent == null) {
return;
}
//黑色的叶子(且是非根节点)
//获取左边还是右边 前面一段判断左还是右,后面一段为了递归 兄弟黑父也为黑的情况
boolean left = parent.left == null || beRemoved.isLeftChild();
//获取兄弟节点 被删除在左边,那就右边
Node sibling = left ? parent.right : parent.left;
//分左右 删除节点在左边
if (left) {
//判断是否是情况2
if (isRed(sibling)) {
//兄弟为红色
black(sibling);
red(parent);
RRroate(parent);
//换兄弟
sibling = parent.right;
}
//情况1的代码,兄弟为黑色
if (isBlack(sibling.left) && isBlack(sibling.right)) {
boolean parentBlack = isBlack(parent);
red(sibling);
black(parent);
if (parentBlack) {
afterRemove(parent, null);
}
} else {
//黑兄弟有红色子节点
Node newParent;
if (isRed(sibling.right)) {
//rr
newParent = RRroate(parent);
} else {
//rl
newParent = RLroate(parent);
}
//旋转后染色
color(newParent, colorOf(parent));
black(newParent.left);
black(newParent.right);
}
} else {
//判断是否是情况2
if (isRed(sibling)) {
//兄弟为红色
black(sibling);
red(parent);
LLroate(parent);
//换兄弟
sibling = parent.left;
}
//情况1的代码 兄弟为黑色
if (isBlack(sibling.left) && isBlack(sibling.right)) {
//黑兄弟无红色子节点
boolean parentBlack = isBlack(parent);
red(sibling);
black(parent);
if (parentBlack) {
afterRemove(parent, null);
}
} else {
//黑兄弟有红色子节点
Node newParent;
if (isRed(sibling.left)) {
// ll
newParent = LLroate(parent);
} else { // lr
newParent = LRroate(parent);
}
//旋转后的根节点继承父节点的颜色
color(newParent, colorOf(parent));
black(newParent.left);
black(newParent.right);
}
}
}
4、可借助链接进行测试
注意：删除的结果不唯一，该网站在删除度为2的节点时，采用的是用其前驱节点替代，同时
删除逻辑中也有一处可采用不同的逻辑。