RBT(红黑树)的删除算法

最新推荐文章于 2025-02-13 10:49:34 发布

wjh1313677

最新推荐文章于 2025-02-13 10:49:34 发布

阅读量808

点赞数

分类专栏：计算机基础文章标签：数据结构

计算机基础专栏收录该内容

1 篇文章

订阅专栏

2-3树中删除最小键

作为一个热身，回到2-3树来看下删除，简单起见，从删除最小键开始。

如果含有最小键的节点不是2节点（3节点或4节点），那么直接删除该节点，不会破坏树的平衡性，但是如果是2节点，由于删除后变为空节点，有可能会破坏平衡性，故删除最小键的思路是沿左链接向下进行变换，确保当前节点不是2节点。

根节点

根节点的左右孩子都为2节点

此时将3个2节点合并为一个4节点

根节点的右孩子不为2节点

左孩子从右孩子中借一个节点过来

其他节点

在沿左链接向下的过程中，左孩子为2节点的情况下，还是通过从右孩子中借一个节点过来，

2-3树删除最小键操作中的变换：

红黑树删除最小键

同样，在红黑树中，如果最小键所在的节点为3节点，即红节点，那么可以直接删除，不会破坏黑色平衡性（任意空链接到头节点路径上的黑链接数量相同）。要保证最小键是红节点，那么在递归删除的过程中需要保证当前节点是红节点或者其左孩子为红节点。这里解释下原因，如果当前节点是红节点且为最小键，直接删除；如果当前节点是3节点中的黑节点，那么进行递归，就可以保证下一步中的节点是红节点，只要判断该红节点是否为最小键所在的节点，是则直接删除。

要保证当前节点是红节点或其左孩子是红节点，那么如何实现呢？这时前面分析的2-3树就派上了用场，从当前节点的父节点入手，不能保证左孩子是3节点或者4节点（即不是2节点）时，那么就要从右孩子中借一个节点，借是通过颜色转换和旋转来实现的。
借一个节点使得当前节点的是红节点（一次颜色变换），对应2-3树中当前节点为4节点：

借一个节点使得当前节点的左孩子为红节点（右左双旋转、颜色变换），对应2-3树中当前节点为3节点：

注意我的代码实现和图中描述的旋转相反，还是因为先入为主，我自己实现的代码命名左旋转和右旋转与《数据结构与算法分析：C语言描述》上一致，与《算法第四版》的命名相反。

为了保证当前节点为红节点或其左孩子是红节点，在这种过程中会引入红色右孩子，这违反了红黑树的定义，在删除后需要修复（每次递归都要修复），修复过程与红黑树插入算法中的修复一样，不赘述了。这里要注意颜色转换的问题，其一：不像插入时显式地设置，删除时每个节点是由颜色的，颜色转换时红变黑或者黑变红；其二：由于第一点原因，从树的头节点开始时，必须将头节点置为红节点。

    //删除最小键  
    private TreeNode deleteMin(TreeNode node) { 
        //递归结束条件，到达左边界
        if (node.left == null)
            return null;

        //保证node或node.left为红节点，注意是从父节点入手
        if (!isRed(node.left) && !isRed(node.left.left))
            node = moveRedLeft(node);

        //递归地在左子树中删除
        node.left = deleteMin(node.left);
        //删除后修复红色右节点（链接）
        return fixUp(node);
    }
    //对于当前节点，从其兄弟节点（父节点的右节点）中借一个节点
    private TreeNode moveRedLeft(TreeNode node) {
        //先颜色转换
        flipColors(node);
        if (isRed(node.right.left)) {
            //判断其兄弟节点的左孩子是否为红，若是，对当前节点的父节点进行左-右双旋转且颜色要转换 
            node.right = rotateWithLeft(node.right);
            node = rotateWithRight(node);
            flipColors(node);
        }
        return node;
    }  
    private void flipColors(TreeNode node){
        node.color = !node.color;
        node.left.color = !node.left.color;
        node.right.color = !node.right.color;
    }
    private TreeNode fixUp(TreeNode node) {
        if (!isRed(node.left) && isRed(node.right))                    
            node = rotateWithRight(node);
        if (isRed(node.left) && isRed(node.left.left)) 
            node = rotateWithLeft(node);
        if (isRed(node.left) && isRed(node.right))     
            flipColors(node);
        return node;
    }
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

红黑树删除最大键

思路和删除最小键类似，但有点不同。

如果含有最大键的的节点相对其父节点来说是红色右孩子，那么直接删除该节点，则不会破坏黑色平衡性，这点可能不是那么好理解，因为红黑树中是不允许出现红色右孩子的，可以换个角度来看，红黑树是2-3树的一种实现，把红黑树的红色链接画平就是2-3树，准确得说是红色左链接，假设允许出现红色右链接，画平依然是2-3树，那么为什么红黑树里面只允许出现红色左链接呢？为了简洁，只有一种红色链接，方便处理，如果有两种红色链接，那么代码实现会更复杂。

如果红黑树采用了上述图中其他做法，将只能保证平衡性，不能保证有序性（中序遍历将不是从小到大）。再继续删除最大键的讨论，先假设树的最右边节点，即含有最大键的节点是一个3节点，用红黑树来实现的话，该节点的将是黑节点，其左孩子是红节点，只要一次左旋转，就会得到红色右链接，红色节点含有最大键，删除即可，不会破坏平衡性和有序性

对于任何一般节点，在不破坏平衡性和有序性的前提下，将树变为含有红色右链接的红黑树，删除最大键后，再通过颜色转换和旋转操作修复。

接下来的讨论和删除最小键就很类似了。要保证最大键是红节点，那么在递归删除的过程中需要保证当前节点是红节点或者其右孩子为红节点。原因也类似，若当前节点为红节点，判断其是否含有最大键，有则删除；当前节点为3节点中的黑节点，递归一次，下一删除中当前节点就是红节点了，判断是否删除即可。
如何保证当前节点是红节点或其有孩子为红节点呢？也是从当前节点的父节点入手，通过向左孩子借一个节点。
借一个节点使得当前节点的是红节点（一次颜色变换），对应2-3树中当前节点为4节点：

借一个节点使得当前节点的右孩子为红节点（右旋转、颜色变换），对应2-3树中当前节点为3节点：

    //删除最大键
    private TreeNode deleteMax(TreeNode node){
         // 使树出现红色右链接
        if(isRed(node.left))
            node = rotateWithLeft(node);
        //注意上下两者的顺序不能错
        //递归结束条件，达到了右边界
        if(node.right == null)
            return null;

        //保证node或node.right为红节点，注意也是从父节点入手
        if(!isRed(node.right) && !isRed(node.right.left))
    //因为3节点是用红节点来模拟的，红节点不可能是右孩子，所以不可能是h.right.right，通过上面的一次左旋转，可以获得与h.right.right同样的效果
            node = moveRedRight(node);
        //递归在右子树中删除
        node.right = deleteMax(node.right);
        return fixUp(node);     
    }
    //对于当前节点，从其兄弟节点（当前节点父节点左孩子）中借一个节点
    private TreeNode moveRedRight(TreeNode node){
        //颜色转换
        flipColors(node);
        if(isRed(node.left.left)){
            //判断其兄弟节点的左孩子是否为红，若是，对当前节点的父节点进行左旋转且颜色要转换
            //每次都是判断兄弟节点的左孩子，因为在借之前，在其父节点下面的节点只能有红色左链接
            node = rotateWithLeft(node);
            flipColors(node);
        }
        return node;
    }
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

同样，也会出现红色右链接，要修复，颜色转换也得注意。

红黑树删除操作

如果理解了上述删除最小键和最大键，那么理解删除任意一个节点就要容易些了，实现比较繁琐。

从树的头节点开始，如果当前节点的键小于待删除的，则在左子树中递归删除，在递归的过程中要保证当前节点或当前节点的左孩子为红节点（同样是从父节点入手)
否则先判断一下当前节点的左孩子是否为红，是则左旋转，将红链接旋转到右孩子
判断待删除的节点是否为当前节点，且右孩子是否为空。此时待删除的节点在树底，包含两种情况：其一，待删除的节点是红色节点，且为叶节点；其二，待删除的节点通过上一步的旋转变为了红色右孩子，且为叶节点
判断待删除的节点是否为当前节点，此时待删除的节点不在树底，若采用后继节点替代的删除方式：与BST类似，先找到右子树的最小节点，将其键值对赋给当前的节点，然后采用递归删除的方式删除右子树中的最小节点（保证链接的正确性）
否则（也就是当前节点的键大于待删除节点的键），递归在右子树中删除，在递归的过程中要保证当前节点或当前节点的右孩子为红节点（同样从父节点入手）。这里要注意这里的否则对应的else语句要放在上一个else中，以保证能将红色左孩子通过旋转变为红色右孩子
最后，记得要修复沿路的红色右节点

还有点要注意，不可在递归的开头定义一个int变量来记录当前节点与待删除节点的比较值，因为在上述第二步中，也就是将红色左孩子旋转变为红色右孩子，树的结构可能会变，应该还要再比较一次的。要是那么做了（一次比较两处使用，就像BST中那样），会有一个bug，当待删除的节点是一个红节点（左孩子）的父节点时，最终该节点不会被删除，而该节点的红色左孩子会被删除，可以调试下，也就是这里的实现。如下图中的X

可能会奇怪，为什么是先左子树、等于、最后再右子树，和BST以及AVL中的左子树、右子树、等于不一样啊？主要是向右子树遍历时，和删除最大键类似，要保证能够删除红色右孩子，但有个问题，如果红色右孩子是叶节点怎么办，前面又没有加递归结束判断条件（即判断当前节点是否为null），向右子树遍历可能会出现空指针异常，此外，逻辑也较清楚。

public void delete(String key){
        if (key == null) throw new NullPointerException("argument to delete() is null");
        if (!isRed(root.left) && !isRed(root.right))
            root.color = RED;
        root = delete(root, key);
        root.color = BLACK;//确保删除后头节点是黑色，因为可能把头节点变红，
    }
    private TreeNode delete(TreeNode node, String key){
//      int cmp = key.compareTo(node.key);//不可以这样，因为后面有旋转操作，可能改变了树的结构，
        if(key.compareTo(node.key) < 0){//递归在左子树中删除
            if(!isRed(node.left) && !isRed(node.left.left))//站在2-3树的角度看，确保删除的节点不为2节点
                node = moveRedLeft(node);
            node.left = delete(node.left, key);
        } else{
            //确保在右子树中能出现红色右孩子
            if(isRed(node.left))
                node = rotateWithLeft(node);

            //待删除的节点在树底
            if(key.compareTo(node.key) == 0 && node.right == null)
                return null;
            //待删除的节点不在树底
            if(key.compareTo(node.key) == 0){
                TreeNode temp = min(node.right);
                node.key = temp.key;
                node.value = temp.value;
                node.right = deleteMin(node.right);
            } else{//递归在右子树中删除
                //若把 递归在右子树中删除 放在  等于  之前，node.right.left可能会出现空指针异常，因为缺少递归结束判断条件
                if(!isRed(node.right) && !isRed(node.right.left))//确保删除的节点不为2节点，
                    node = moveRedRight(node);
                node.right = delete(node.right, key);
            }
        }
        return fixUp(node);//修复红色右节点
    }
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

最后附上所有代码及测试用例：

package BinarySearchTree;

import java.util.*;
/**
 * 红黑树
 * @author 小锅巴
 */
public class RBT {
    private static final boolean RED = true;
    private static final boolean BLACK = false;

    private TreeNode root;

    private class TreeNode{
        String key;
        int value;
        TreeNode left, right;//左右链接
        boolean color;//节点的颜色

        TreeNode(String key, int value, boolean color){
            this.key = key;
            this.value = value;
            this.color = color;//新建节点，每次都是红色的
        }
    }

    private boolean isRed(TreeNode node){
        if(node == null)
            return false;
        return node.color == RED;
    }

    //左旋转，由于我先学得AVL，先入为主，我以维斯版的来命名，与algs4的相反
    private TreeNode rotateWithLeft(TreeNode node){
        TreeNode temp = node.left;
        //完成旋转
        node.left = temp.right;
        temp.right = node;
        //和AVL相比，旋转后要变换颜色，
        temp.color = node.color;
        node.color = RED;//被旋转的节点到了子树，所以肯定是设置被旋转的节点为红色节点
        return temp;
    }

    //右旋转
    private TreeNode rotateWithRight(TreeNode node){
        TreeNode temp = node.right;

        node.right = temp.left;
        temp.left = node;

        temp.color = node.color;
        node.color = RED;

        return temp;
    }

    //颜色转换的条件是左右子节点均为红节点，由红节点的定义，那么当前节点的的孩子均不会为null，不会出现空指针异常
    private void flipColors(TreeNode node){
//      node.color = RED;
//      node.left.color = BLACK;
//      node.right.color = BLACK;
        node.color = !node.color;
        node.left.color = !node.left.color;
        node.right.color = !node.right.color;
    }

    //修复红色右节点以及一个节点和两条红链接相连
    private TreeNode fixUp(TreeNode node) {
        if (!isRed(node.left) && isRed(node.right))                    
            node = rotateWithRight(node);
        if (isRed(node.left) && isRed(node.left.left)) 
            node = rotateWithLeft(node);
        if (isRed(node.left) && isRed(node.right))     
            flipColors(node);
        return node;
    }

    public int get(String key){
        return get(root, key);
    }
    private int get(TreeNode node, String key){
        if(node == null)
            return -1;
        int cmp = key.compareTo(node.key);
        if(cmp < 0)
            return get(node.left, key);
        else if(cmp > 0)
            return get(node.right, key);
        else
            return node.value;
    }
    public void insert(String key, int value){
        root = insert(root, key, value);
        root.color = BLACK;//根节点都是黑色
    }
    private TreeNode insert(TreeNode node, String key, int value){
        if( node == null)
            return new TreeNode(key, value, RED);

        int cmp = key.compareTo(node.key);
        if(cmp < 0)
            node.left = insert(node.left, key, value);
        else if(cmp > 0)
            node.right = insert(node.right, key, value);
        else
            node.value = value;

        //旋转
//      if(!isRed(node.left) && isRed(node.right))//左链接为黑，右链接为红，则右旋转
//          node = rotateWithRight(node);
//      if(isRed(node.left.left) && isRed(node.left))//左链接为红，左孩子的左链接也为红，则左旋转
//          node = rotateWithLeft(node);
//      if(isRed(node.left) && isRed(node.right))//左右链接均为红，调整颜色
//          flipColors(node);
//      return node;
        return fixUp(node);
    }

    //找出最小键
    private TreeNode min(TreeNode node){
        while(node.left != null)
            node = node.left;
        return node;
    }

    //删除最小键
    private TreeNode deleteMin(TreeNode node) { 
        //递归结束条件，到达左边界
        if (node.left == null)
            return null;

        //保证node或node.left为红节点，注意是从父节点入手
        if (!isRed(node.left) && !isRed(node.left.left))
            node = moveRedLeft(node);

        //递归地在左子树中删除
        node.left = deleteMin(node.left);
        //删除后修复红色右节点（链接）
        return fixUp(node);
    }

    //对于当前节点，从其兄弟节点（父节点的右节点）中借一个节点
    private TreeNode moveRedLeft(TreeNode node) {
        //先颜色转换
        flipColors(node);
        if (isRed(node.right.left)) {
            //判断其兄弟节点的左孩子是否为红，若是，对当前节点的父节点进行左-右双旋转且颜色要转换 
            node.right = rotateWithLeft(node.right);
            node = rotateWithRight(node);
            flipColors(node);
        }
        return node;
    }

    //找出最大键
    private TreeNode max(TreeNode node){
        while(node.right != null)
            node = node.right;
        return node;
    }

    //删除最大键
    private TreeNode deleteMax(TreeNode node){
         // 使树出现红色右链接
        if(isRed(node.left))
            node = rotateWithLeft(node);
        //注意上下两者的顺序不能错
        //递归结束条件，达到了右边界
        if(node.right == null)
            return null;

        //保证node或node.right为红节点，注意也是从父节点入手
        if(!isRed(node.right) && !isRed(node.right.left))
    //因为3节点是用红节点来模拟的，红节点不可能是右孩子，所以不可能是h.right.right，通过上面的一次左旋转，可以获得与h.right.right同样的效果
            node = moveRedRight(node);
        //递归在右子树中删除
        node.right = deleteMax(node.right);
        return fixUp(node);     
    }

    //对于当前节点，从其兄弟节点（当前节点父节点左孩子）中借一个节点
    private TreeNode moveRedRight(TreeNode node){
        //颜色转换
        flipColors(node);
        if(isRed(node.left.left)){
            //判断其兄弟节点的左孩子是否为红，若是，对当前节点的父节点进行左旋转且颜色要转换
            //每次都是判断兄弟节点的左孩子，因为在借之前，在其父节点下面的节点只能有红色左链接
            node = rotateWithLeft(node);
            flipColors(node);
        }
        return node;
    }

    public void delete(String key){
        if (key == null) throw new NullPointerException("argument to delete() is null");
        if (!isRed(root.left) && !isRed(root.right))
            root.color = RED;
        root = delete(root, key);
        root.color = BLACK;//确保删除后头节点是黑色，因为可能把头节点变红，
    }
    private TreeNode delete(TreeNode node, String key){
//      int cmp = key.compareTo(node.key);//不可以这样，因为后面有旋转操作，可能改变了树的结构，
        if(key.compareTo(node.key) < 0){//递归在左子树中删除
            if(!isRed(node.left) && !isRed(node.left.left))//站在2-3树的角度看，确保删除的节点不为2节点
                node = moveRedLeft(node);
            node.left = delete(node.left, key);
        } else{
            //确保在右子树中能出现红色右孩子
            if(isRed(node.left))
                node = rotateWithLeft(node);

            //待删除的节点在树底
            if(key.compareTo(node.key) == 0 && node.right == null)
                return null;
            //待删除的节点不在树底
            if(key.compareTo(node.key) == 0){
                TreeNode temp = min(node.right);
                node.key = temp.key;
                node.value = temp.value;
                node.right = deleteMin(node.right);
            } else{//递归在右子树中删除
                //若把 递归在右子树中删除 放在  等于  之前，node.right.left可能会出现空指针异常，因为缺少递归结束判断条件
                if(!isRed(node.right) && !isRed(node.right.left))//确保删除的节点不为2节点，
                    node = moveRedRight(node);
                node.right = delete(node.right, key);
            }
        }
        return fixUp(node);//修复红色右节点
    }

    //层序遍历所有节点的键
    private void layerTraversal (TreeNode node){
        Queue<TreeNode> s = new LinkedList<>();
        s.add(node);
        TreeNode curNode;
        TreeNode nlast = null;
        TreeNode last = node;
        while(!s.isEmpty()){
            curNode = s.poll();
            System.out.print(curNode.key+" ");
            if(curNode.left != null){
                nlast = curNode.left;
                s.add(curNode.left);
            }
            if(curNode.right != null){
                nlast = curNode.right;
                s.add(curNode.right);
            }
            if(curNode == last){
                System.out.println();
                last = nlast;
            }
        }
    }

    //层序遍历节点的颜色（是否为红）
    private void layerTraversalColor (TreeNode node){
        Queue<TreeNode> s = new LinkedList<>();
        s.add(node);
        TreeNode curNode;
        TreeNode nlast = null;
        TreeNode last = node;
        while(!s.isEmpty()){
            curNode = s.poll();
            System.out.print(curNode.color+" ");
            if(curNode.left != null){
                nlast = curNode.left;
                s.add(curNode.left);
            }
            if(curNode.right != null){
                nlast = curNode.right;
                s.add(curNode.right);
            }
            if(curNode == last){
                System.out.println();
                last = nlast;
            }
        }
    }

    //先序遍历所有节点的键，
    private void preOrderTraversal(TreeNode node){
        Stack<TreeNode> s = new Stack<>();
        TreeNode curNode = null;
        s.push(node);
        while(!s.isEmpty()){
            curNode = s.pop();
            System.out.print(curNode.key+" ");
            if(curNode.right != null)
                s.push(curNode.right);
            if(curNode.left != null)
                s.push(curNode.left);
        }
    }

    public static void main(String[] args) {
        RBT rbt = new RBT();
        System.out.print("请输入节点个数：");
        Scanner s = new Scanner(System.in);
        int num = s.nextInt();
        System.out.println("请依次输入"+num+"个字母");
        for (int i = 1; i <= num; i++){
            String value = s.next();
            rbt.insert(value, i);
        }


        System.out.println("节点颜色是否为红：");
        rbt.layerTraversalColor(rbt.root);
        System.out.println();

        System.out.println("层序遍历");
        rbt.layerTraversal(rbt.root);
        System.out.println();

        System.out.println("先序遍历");
        rbt.preOrderTraversal(rbt.root);
        System.out.println();


//      rbt.deleteMin();
//      System.out.println("测试删除最小键：");
//      System.out.println("节点颜色是否为红：");
//      rbt.layerTraversalColor(rbt.root);
//      System.out.println();
//      
//      System.out.println("层序遍历");
//      rbt.layerTraversal(rbt.root);
//      System.out.println();
//      
//      System.out.println("先序遍历");
//      rbt.preOrderTraversal(rbt.root);
//      System.out.println();
//      
//      
//      rbt.deleteMax();
//      System.out.println("测试删除最大键");
//      System.out.println("节点颜色是否为红：");
//      rbt.layerTraversalColor(rbt.root);
//      System.out.println();
//      
//      System.out.println("层序遍历");
//      rbt.layerTraversal(rbt.root);
//      System.out.println();
//      
//      System.out.println("先序遍历");
//      rbt.preOrderTraversal(rbt.root);
//      System.out.println();

        System.out.println("\n"+"测试删除任意键");
        System.out.println("请输入要删除的键:");
        String key = s.next();
        rbt.delete(key);
        System.out.println("节点颜色是否为红：");
        rbt.layerTraversalColor(rbt.root);
        System.out.println();

        System.out.println("层序遍历");
        rbt.layerTraversal(rbt.root);
        System.out.println();

        System.out.println("先序遍历");
        rbt.preOrderTraversal(rbt.root);
        System.out.println();
    }
}

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368

测试用例：

请输入节点个数：10
请依次输入10个字母
S
E
A
R
C
H
X
M
P
L
节点颜色是否为红：
false 
false false 
false false false false 
true true true 

层序遍历
M 
E R 
C L P X 
A H S 

先序遍历
M E C A L H R P X S 

测试删除任意键
请输入要删除的键:
X
节点颜色是否为红：
false 
false false 
false false false false 
true true 

层序遍历
M 
E R 
C L P S 
A H 

先序遍历
M E C A L H R P S 

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

请输入节点个数：10
请依次输入10个字母
S
E
A
R
C
H
X
M
P
L
节点颜色是否为红：
false 
false false 
false false false false 
true true true 

层序遍历
M 
E R 
C L P X 
A H S 

先序遍历
M E C A L H R P X S 

测试删除任意键
请输入要删除的键:
S
节点颜色是否为红：
false 
false false 
false false false false 
true true 

层序遍历
M 
E R 
C L P X 
A H 

先序遍历
M E C A L H R P X 

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

请输入节点个数：10
请依次输入10个字母
S
E
A
R
C
H
X
M
P
L
节点颜色是否为红：
false 
false false 
false false false false 
true true true 

层序遍历
M 
E R 
C L P X 
A H S 

先序遍历
M E C A L H R P X S 

测试删除任意键
请输入要删除的键:
M
节点颜色是否为红：
false 
false false 
false false false false 
true true 

层序遍历
P 
E S 
C L R X 
A H 

先序遍历
P E C A L H S R X 

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45