第十章 红黑树（Red Black Tree）

最新推荐文章于 2024-07-09 14:31:01 发布
最新推荐文章于 2024-07-09 14:31:01 发布
阅读量229 收藏 1
点赞数 1
分类专栏： 恋上数据结构与算法 第一季 文章标签： 红黑树 b树 平衡二叉树 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sj15814963053/article/details/123981642
版权

第十章 红黑树（Red Black Tree）

一开始学红黑树必然一脸懵逼，学完再看还是一脸懵逼

Untitled

红黑树介绍

红黑树也是一种自平衡的二叉搜索树

  • 以前也叫做平衡二叉B树（Symmetric Binary B-tree）

Untitled

红黑树必须满足以下 5 条性质：

Untitled

请问下面这棵是红黑树么？ （不是一棵红黑树）

Untitled

红黑树的等价变换

  • 有如下一棵红黑树：

Untitled

  • 上面那棵红黑树变成了下面这个样子：

Untitled

  • 下面是一个与上面的红黑树等价的 4阶B树

Untitled

  • 红黑树 和 4阶B树（2-3-4树）具有等价性
  • BLACK 节点与它的 RED 子节点融合在一起，形成1个B树节点
  • 红黑树的 BLACK节点个数 与 4阶B树的节点总个数相等
  • 网上有些教程：用 2-3树 与 红黑树 进行类比，这是极其不严谨的， 2-3树 并不能完美匹配 红黑树 的所有情况
  • 注意：因为界面空间有限，后面展示的红黑树都会省略 NULL 节点

红黑树 vs 2-3-4树

Untitled

  • 思考：如果上图最底层的 BLACK 节点是不存在的，在 B树 中是什么样的情形？
    • 整棵 B树 只有一个节点，而且是超级节点

几个英文单词

Untitled

  • parent：父节点
  • sibling：兄弟节点
  • uncle：叔父节点（ parent 的兄弟节点）
  • grand：祖父节点（ parent 的父节点）

红黑树基础代码

package cn.xx.java.tree;

import java.util.Comparator;

/**
 * @author xiexu
 * @create 2021-08-09 9:24 上午
 */
public class RBTree<E> extends BST<E> {
    private static final boolean RED = false;
    private static final boolean BLACK = true;

    public RBTree() {
        this(null);
    }

    public RBTree(Comparator<E> comparator) {
        super(comparator);
    }

    /**
     * 给节点染色
     *
     * @param node
     * @param color
     * @return
     */
    private Node<E> color(Node<E> node, boolean color) {
        if (node == null) {
            return node;
        }
        ((RBNode<E>) node).color = color;
        return node;
    }

    /**
     * 把节点染成红色
     *
     * @param node
     * @return
     */
    private Node<E> red(Node<E> node) {
        return color(node, RED);
    }

    /**
     * 把节点染成黑色
     *
     * @param node
     * @return
     */
    private Node<E> black(Node<E> node) {
        return color(node, BLACK);
    }

    /**
     * 判断当前节点是什么颜色的
     * 空节点默认是黑色
     *
     * @param node
     * @return
     */
    private boolean colorOf(Node<E> node) {
        return node == null ? BLACK : ((RBNode<E>) node).color;
    }

    /**
     * 当前节点是否为黑色
     *
     * @param node
     * @return
     */
    private boolean isBlack(Node<E> node) {
        return colorOf(node) == BLACK;
    }

    /**
     * 当前节点是否为红色
     *
     * @param node
     * @return
     */
    private boolean isRed(Node<E> node) {
        return colorOf(node) == RED;
    }

    /**
     * 红黑树节点
     *
     * @param <E>
     */
    private static class RBNode<E> extends Node<E> {

        boolean color;

        public RBNode(E element, Node<E> parent) {
            super(element, parent);
        }
    }

}

添加

  • B树中，新元素必定是添加到叶子节点中
  • 4阶B树所有节点的元素个数 x 都符合 1 <= x <= 3
  • 建议新添加的节点默认为 RED，这样能够让红黑树的性质尽快满足（性质 1、2、3、5 都满足，性质 4 不一定）

Untitled

  • 如果添加的是根节点，染成 BLACK 即可

添加的所有情况

  • 添加的情况总共有12种，如下图

Untitled

  • 有4种情况满足红黑树的性质 4：parent 为 BLACK
    • 同样也满足 4阶B树 的性质
    • 因此不用做任何额外处理

Untitled

  • 有 8 种情况不满足红黑树的性质 4：parent 为 RED（Double Red）
    • 其中前 4 种属于B树节点上溢的情况

Untitled

添加 - 修复性质4 - LL \ RR

  • 判定条件：uncle 不是 RED
  1. parent 染成 BLACK，grand 染成 RED
  2. grand 进行单旋操作
  • LL：右旋转
  • RR：左旋转

Untitled

  • 修复后就是下面这样子

Untitled

添加 - 修复性质4 - LR \ RL

  • 判定条件：uncle 不是 RED
  1. 自己染成 BLACK，grand 染成 RED
  2. 进行双旋操作
  • LR：parent 左旋转，grand 右旋转
  • RL：parent 右旋转，grand 左旋转

Untitled

  • 修复后就是下面这样子

Untitled

添加 - 修复性质4 - 上溢 - LL

  • 判定条件：uncle 是 RED
  1. parent、uncle 染成 BLACK
  2. Grand 向上合并
    1. 染成 RED，当做是新添加的节点进行处理

Untitled

  • grand 向上合并时，可能继续发生上溢
  • 若上溢持续到根节点，只需将根节点染成 BLACK

Untitled

添加 - 修复性质4 - 上溢 - RR

  • 判定条件：uncle 是 RED
  1. parent、uncle 染成 BLACK
  2. grand 向上合并
    1. 染成 RED，当做是新添加的节点进行处理

Untitled

  • grand 向上合并时，可能继续发生上溢
  • 若上溢持续到根节点，只需将根节点染成 BLACK

Untitled

添加 - 修复性质4 - 上溢 - LR

  • 判定条件：uncle 是 RED
  1. parent、uncle 染成 BLACK
  2. grand 向上合并
    1. 染成 RED，当做是新添加的节点进行处理

Untitled

  • grand 向上合并时，可能继续发生上溢
  • 若上溢持续到根节点，只需将根节点染成 BLACK

Untitled

添加 - 修复性质4 - 上溢 - RL

  • 判定条件：uncle 是 RED
  1. parent、uncle 染成 BLACK
  2. grand 向上合并
    1. 染成 RED，当做是新添加的节点进行处理

Untitled

  • grand 向上合并时，可能继续发生上溢
  • 若上溢持续到根节点，只需将根节点染成 BLACK

Untitled

添加节点 - 代码实现

/**
 * 添加节点之后的操作
 *
 * @param node 新添加的节点
 */
@Override
protected void afterAdd(Node<E> node) {
    Node<E> parent = node.parent;

    //添加的是根节点
    if (parent == null) {
        black(node); //直接将根节点染成黑色
        return;
    }

    //如果父节点是黑色，则直接返回
    if (isBlack(parent)) {
        return;
    }

    //uncle节点
    Node<E> uncle = parent.sibling();
    //grand节点
    Node<E> grand = parent.parent;

    //uncle节点是红色
    if (isRed(uncle)) {
        black(parent);
        black(uncle);
        red(grand);
        //祖父节点当做是新添加的节点
        afterAdd(grand);
        return;
    }

    //uncle节点不是红色
    if (parent.isLeftChild()) { //L
        if (node.isLeftChild()) { //LL
            black(parent);
            red(grand);
            rotateRight(grand); //右旋
        } else { //LR
            black(node);
            red(grand);
            rotateLeft(parent); //左旋
            rotateRight(grand); //右旋
        }
    } else { //R
        if (node.isLeftChild()) { //RL
            black(node);
            red(grand);
            rotateRight(parent); //右旋
            rotateLeft(grand); //左旋
        } else { //RR
            black(parent);
            red(grand);
            rotateLeft(grand); //左旋
        }
    }

}

删除

  • B树中，最后真正被删除的元素都在叶子节点中

Untitled

删除 - RED节点

Untitled

  • 直接删除，不用作任何调整

Untitled

删除 - BLACK节点

Untitled

有3种情况

  • 拥有2个 RED 子节点的 BLACK 节点
    • 不可能被直接删除，因为会找它的子节点替代删除
    • 因此不用考虑这种情况

Untitled

  • 拥有1个 RED 子节点的 BLACK 节点
  • BLACK 叶子节点

Untitled

删除 - 拥有1个RED子节点的BLACK节点

  • 判定条件：用以替代的子节点是 RED

Untitled

Untitled

  • 将替代的子节点染成 BLACK 即可保持红黑树性质

Untitled

删除 - BLACK 叶子节点 - sibling为 BLACK

  • BLACK 叶子节点被删除后，会导致B树节点下溢（比如删除88）
  • 如果 sibling 至少有1个 RED 子节点
    • 进行旋转操作
    • 旋转之后的中心节点继承 parent 的颜色
    • 旋转之后的左右节点染为 BLACK

Untitled

示例一：

  • 以删除 88 节点为例

Untitled

  • 下图所示是 LR 情况

Untitled

  • 先对 76 进行左旋，再对 80 进行右旋
  • 88 的 parent 节点是80，80的颜色是 RED
  • 所以 78 的颜色染为 80 的颜色 RED
  • 左右节点 76 和 80 染为 BLACK

Untitled

示例二：

  • 以删除 88 节点为例

Untitled

  • 下图所示是 RL 情况

Untitled

  • 先对 76 进行右旋，再对 80 进行左旋
  • 88 的 parent 节点是80，80的颜色是 RED
  • 所以 76 的颜色染为 80 的颜色 RED
  • 左右节点 72 和 80 染为 BLACK

Untitled

示例三：

  • 以删除 88 节点为例

Untitled

  • 下图所示是 LL / LR，这里以 LL 来说明

Untitled

  • 对 80 进行右旋转
  • 88 的 parent 节点是80，80的颜色是 RED
  • 所以 76 的颜色染为 80 的颜色 RED
  • 左右节点 72 和 80 染为 BLACK

Untitled

示例四：

  • 以删除 88 节点为例

Untitled

  • 下图所示是 LL / LR，这里以 LR 来说明

Untitled

  • 对 76 进行左旋转，对 80 进行右旋转
  • 88 的 parent 节点是80，80的颜色是 RED
  • 所以 78 的颜色染为 80 的颜色 RED
  • 左右节点 76 和 80 染为 BLACK

Untitled

删除 - BLACK叶子节点 - sibling为BLACK

  • 判定条件：sibling 没有1个 RED 子节点
  • 将 sibling 染成 RED、parent 染成 BLACK 即可修复红黑树性质

Untitled

Untitled

Untitled

  • 如果 parent 是 BLACK
    • 会导致 parent 也下溢
    • 这时只需要把 parent 当做被删除的节点处理即可

Untitled

Untitled

Untitled

删除 - BLACK叶子节点 - sibling为RED

  • 如果 sibling 是 RED
    • Sibling 染成 BLACK，parent 染成 RED，进行旋转
    • 于是又回到 sibling 是 BLACK 的情况

Untitled

Untitled

Untitled

删除节点源代码

/**
 * 删除节点之后的操作
 *
 * @param node 被删除的节点 或者 用以取代被删除节点的子节点（当被删除节点的度为1）
 */
@Override
protected void afterRemove(Node<E> node) {

    //如果删除的节点是红色 或者 用以取代删除节点的子节点是红色
    if (isRed(node)) {
        black(node);
        return;
    }

    //parent节点
    Node<E> parent = node.parent;

    //删除的是根节点
    if (parent == null) {
        return;
    }

    //删除的是黑色叶子节点[下溢]
    //判断被删除的node是左还是右，因为被删除后该父节点的一边就会为空，所以兄弟节点就在另一边
    boolean left = parent.left == null || node.isLeftChild();
    Node<E> sibling = left ? parent.right : parent.left;
    if (left) { //被删除的节点在左边，兄弟节点在右边
        if (isRed(sibling)) { //兄弟节点是红色
            black(sibling); //兄弟节点染成黑色
            red(parent); //parent节点染成红色
            rotateLeft(parent); //右旋
            //更换兄弟
            sibling = parent.right;
        }

        //兄弟节点必然是黑色
        //如果左右节点为null，null也是黑色
        if (isBlack(sibling.left) && isBlack(sibling.right)) {
            //兄弟节点没有一个红色子节点，父节点要向下跟兄弟节点合并
            boolean parentBlack = isBlack(parent); //处理之前先检查下父节点是不是黑色
            black(parent);
            red(sibling);
            if (parentBlack) {
                //只需把 parent 当做被删除的节点处理即可
                afterRemove(parent);
            }
        } else { //兄弟节点至少有1个红色子节点，向兄弟节点借元素
            //兄弟节点的右边是黑色，要对兄弟节点进行左旋转
            if (isBlack(sibling.right)) {
                rotateRight(sibling);
                sibling = parent.right; //兄弟节点要重新赋值
            }

            //sibling继承parent的颜色
            color(sibling, colorOf(parent));
            black(sibling.right);
            black(parent);

            rotateLeft(parent);
        }
    } else { //被删除的节点在右边，兄弟节点在左边

        if (isRed(sibling)) { //兄弟节点是红色
            black(sibling); //兄弟节点染成黑色
            red(parent); //parent节点染成红色
            rotateRight(parent); //右旋
            //更换兄弟
            sibling = parent.left;
        }

        //兄弟节点必然是黑色
        //如果左右节点为null，null也是黑色
        if (isBlack(sibling.left) && isBlack(sibling.right)) {
            //兄弟节点没有一个红色子节点，父节点要向下跟兄弟节点合并
            boolean parentBlack = isBlack(parent); //处理之前先检查下父节点是不是黑色
            black(parent);
            red(sibling);
            if (parentBlack) {
                //只需把 parent 当做被删除的节点处理即可
                afterRemove(parent);
            }
        } else { //兄弟节点至少有1个红色子节点，向兄弟节点借元素
            //兄弟节点的左边是黑色，要对兄弟节点进行左旋转
            if (isBlack(sibling.left)) {
                rotateLeft(sibling);
                sibling = parent.left; //兄弟节点要重新赋值
            }

            //sibling继承parent的颜色
            color(sibling, colorOf(parent));
            black(sibling.left);
            black(parent);

            rotateRight(parent);
        }
    }
}

红黑树的平衡

  • 最初遗留的困惑：为何那5条性质，就能保证红黑树是平衡的？
    • 那5条性质，可以保证 红黑树 等价于 4阶B树

Untitled

  • 相比AVL树，红黑树的平衡标准比较宽松：没有一条路径会大于其他路径的2倍
  • 是一种弱平衡、黑高度平衡
  • 红黑树的最大高度是 2 * log2( n + 1 )，依然是 O( logn )级别

平均时间复杂度

  • 搜索：O( logn )
  • 添加：O( logn )，O( 1 )次的旋转操作
  • 删除：O( logn )，O( 1 )次的旋转操作

AVL树 VS 红黑树

Untitled

红黑树完整源代码

BinaryTree类

package cn.xx.java.tree;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.Queue;

/**
 * 二叉搜索树
 *
 * @author xiexu
 * @create 2021-07-26 12:13 下午
 */
public class BST<E> extends BinaryTree<E> {
    private Comparator<E> comparator;

    public BST() {
        this(null);
    }

    public BST(Comparator<E> comparator) {
        this.comparator = comparator;
    }

    private void elementNotNullCheck(E element) {
        if (element == null) {
            throw new IllegalArgumentException("element must not be null");
        }
    }

    /**
     * 添加元素
     *
     * @param element
     */
    public void add(E element) {
        //判空
        elementNotNullCheck(element);

        //根节点为空，相当于添加第一个节点
        if (root == null) {
            root = createNode(element, null);
            size++;
            //新添加节点之后的处理
            afterAdd(root);
            return;
        }
        //添加的不是第一个节点
        //找到父节点
        Node<E> parent = root;
        Node<E> node = root;
        int cmp = 0;
        while (node != null) {
            cmp = commpare(element, node.element);
            parent = node;
            if (cmp > 0) {
                node = node.right;
            } else if (cmp < 0) {
                node = node.left;
            } else { //相等直接返回
                node.element = element;
                return;
            }
        }
        //找到父节点，看看插入到父节点的哪个位置
        Node<E> newNode = createNode(element, parent); //创建新节点
        if (cmp > 0) {
            parent.right = newNode;
        } else {
            parent.left = newNode;
        }
        size++;

        //新添加节点之后的处理
        afterAdd(newNode);
    }

    /**
     * 添加node之后的调整
     *
     * @param node 新添加的节点
     */
    protected void afterAdd(Node<E> node) {
    }

    /**
     * 删除node之后的调整
     *
     * @param node 被删除的节点 或者 用以取代被删除节点的子节点（当被删除节点的度为1）
     */
    protected void afterRemove(Node<E> node) {
    }

    public void remove(E element) {
        remove(node(element));
    }

    private void remove(Node<E> node) {
        if (node == null) {
            return;
        }
        size--;
        if (node.hasTwoChildren()) { //度为2的节点
            //找到后继节点
            Node<E> s = successor(node);
            //用后继节点的值，覆盖度为2的节点的值
            node.element = s.element;
            //删除后继节点
            node = s;
        }

        //删除node节点（node的度必然是1或者0）
        Node<E> replacement = node.left != null ? node.left : node.right;

        if (replacement != null) { //node是度为1的节点
            //更改parent
            replacement.parent = node.parent;
            //更改parent的left，right的指向
            if (node.parent == null) { //node是度为1的节点并且是根节点
                root = replacement;
            } else {
                if (node == node.parent.left) {
                    node.parent.left = replacement;
                } else { //node == node.parent.right
                    node.parent.right = replacement;
                }
            }

            //删除节点之后的处理
            afterRemove(replacement);
        } else if (node.parent == null) { //node是叶子节点并且是根节点
            root = null;

            //删除节点之后的处理
            afterRemove(node);
        } else { //node是叶子节点，但不是根节点
            if (node == node.parent.left) {
                node.parent.left = null;
            } else { //node == node.parent.right
                node.parent.right = null;
            }

            //删除节点之后的处理
            afterRemove(node);
        }
    }

    private Node<E> node(E element) {
        Node<E> node = root;
        while (node != null) {
            int cmp = commpare(element, node.element);
            if (cmp == 0) {
                return node;
            } else if (cmp > 0) {
                node = node.right;
            } else { //cmp < 0
                node = node.left;
            }
        }
        return null;
    }

    /**
     * 判断元素是否存在
     *
     * @param element
     * @return
     */
    public boolean contains(E element) {
        return node(element) != null;
    }

    /**
     * @param e1
     * @param e2
     * @return 返回值等于0，代表e1和e2相等；返回值大于0，代表e1大于e2；返回值小于0，代表e1小于e2
     */
    private int commpare(E e1, E e2) {
        if (comparator != null) {
            return comparator.compare(e1, e2);
        } else {
            return ((Comparable<E>) e1).compareTo(e2);
        }
    }

    /**
     * 前序遍历
     */
    public void preorderTraversal() {
        preorderTraversal(root);
    }

    private void preorderTraversal(Node<E> node) {
        if (node == null) {
            return;
        }
        //先访问根节点
        System.out.println(node.element);
        //访问左子节点
        preorderTraversal(node.left);
        //访问右子节点
        preorderTraversal(node.right);
    }

    /**
     * 中序遍历
     */
    public void inorderTraversal() {
        inorderTraversal(root);
    }

    private void inorderTraversal(Node<E> node) {
        if (node == null) {
            return;
        }
        //先中序遍历左子树
        inorderTraversal(node.left);
        //输出根节点
        System.out.println(node.element);
        //再中序遍历右子树
        inorderTraversal(node.right);
    }

    /**
     * 后序遍历
     */
    public void postorderTraversal() {
        postorderTraversal(root);
    }

    private void postorderTraversal(Node<E> node) {
        if (node == null) {
            return;
        }
        //先遍历左子树
        postorderTraversal(node.left);
        //再遍历右子树
        postorderTraversal(node.right);
        //最后访问根节点
        System.out.println(node.element);
    }

    /**
     * 层序遍历
     */
    public void levelOrderTranversal() {
        if (root == null) {
            return;
        }
        Queue<Node<E>> queue = new LinkedList<>();
        //将头节点入队
        queue.offer(root);
        while (!queue.isEmpty()) {
            //将头结点出队
            Node<E> node = queue.poll();
            System.out.println(node.element);
            //如果左子节点不为空，就将左子节点入队
            if (node.left != null) {
                queue.offer(node.left);
            }
            //如果右子节点不为空，就将右子节点入队
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }

}

BST类

package cn.xx.java.tree;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.Queue;

/**
 * 二叉搜索树
 *
 * @author xiexu
 * @create 2021-07-26 12:13 下午
 */
public class BST<E> extends BinaryTree<E> {
    private Comparator<E> comparator;

    public BST() {
        this(null);
    }

    public BST(Comparator<E> comparator) {
        this.comparator = comparator;
    }

    private void elementNotNullCheck(E element) {
        if (element == null) {
            throw new IllegalArgumentException("element must not be null");
        }
    }

    /**
     * 添加元素
     *
     * @param element
     */
    public void add(E element) {
        //判空
        elementNotNullCheck(element);

        //根节点为空，相当于添加第一个节点
        if (root == null) {
            root = createNode(element, null);
            size++;
            //新添加节点之后的处理
            afterAdd(root);
            return;
        }
        //添加的不是第一个节点
        //找到父节点
        Node<E> parent = root;
        Node<E> node = root;
        int cmp = 0;
        while (node != null) {
            cmp = commpare(element, node.element);
            parent = node;
            if (cmp > 0) {
                node = node.right;
            } else if (cmp < 0) {
                node = node.left;
            } else { //相等直接返回
                node.element = element;
                return;
            }
        }
        //找到父节点，看看插入到父节点的哪个位置
        Node<E> newNode = createNode(element, parent); //创建新节点
        if (cmp > 0) {
            parent.right = newNode;
        } else {
            parent.left = newNode;
        }
        size++;

        //新添加节点之后的处理
        afterAdd(newNode);
    }

    /**
     * 添加node之后的调整
     *
     * @param node 新添加的节点
     */
    protected void afterAdd(Node<E> node) {
    }

    /**
     * 删除node之后的调整
     *
     * @param node 被删除的节点 或者 用以取代被删除节点的子节点（当被删除节点的度为1）
     */
    protected void afterRemove(Node<E> node) {
    }

    public void remove(E element) {
        remove(node(element));
    }

    private void remove(Node<E> node) {
        if (node == null) {
            return;
        }
        size--;
        if (node.hasTwoChildren()) { //度为2的节点
            //找到后继节点
            Node<E> s = successor(node);
            //用后继节点的值，覆盖度为2的节点的值
            node.element = s.element;
            //删除后继节点
            node = s;
        }

        //删除node节点（node的度必然是1或者0）
        Node<E> replacement = node.left != null ? node.left : node.right;

        if (replacement != null) { //node是度为1的节点
            //更改parent
            replacement.parent = node.parent;
            //更改parent的left，right的指向
            if (node.parent == null) { //node是度为1的节点并且是根节点
                root = replacement;
            } else {
                if (node == node.parent.left) {
                    node.parent.left = replacement;
                } else { //node == node.parent.right
                    node.parent.right = replacement;
                }
            }

            //删除节点之后的处理
            afterRemove(replacement);
        } else if (node.parent == null) { //node是叶子节点并且是根节点
            root = null;

            //删除节点之后的处理
            afterRemove(node);
        } else { //node是叶子节点，但不是根节点
            if (node == node.parent.left) {
                node.parent.left = null;
            } else { //node == node.parent.right
                node.parent.right = null;
            }

            //删除节点之后的处理
            afterRemove(node);
        }
    }

    private Node<E> node(E element) {
        Node<E> node = root;
        while (node != null) {
            int cmp = commpare(element, node.element);
            if (cmp == 0) {
                return node;
            } else if (cmp > 0) {
                node = node.right;
            } else { //cmp < 0
                node = node.left;
            }
        }
        return null;
    }

    /**
     * 判断元素是否存在
     *
     * @param element
     * @return
     */
    public boolean contains(E element) {
        return node(element) != null;
    }

    /**
     * @param e1
     * @param e2
     * @return 返回值等于0，代表e1和e2相等；返回值大于0，代表e1大于e2；返回值小于0，代表e1小于e2
     */
    private int commpare(E e1, E e2) {
        if (comparator != null) {
            return comparator.compare(e1, e2);
        } else {
            return ((Comparable<E>) e1).compareTo(e2);
        }
    }

    /**
     * 前序遍历
     */
    public void preorderTraversal() {
        preorderTraversal(root);
    }

    private void preorderTraversal(Node<E> node) {
        if (node == null) {
            return;
        }
        //先访问根节点
        System.out.println(node.element);
        //访问左子节点
        preorderTraversal(node.left);
        //访问右子节点
        preorderTraversal(node.right);
    }

    /**
     * 中序遍历
     */
    public void inorderTraversal() {
        inorderTraversal(root);
    }

    private void inorderTraversal(Node<E> node) {
        if (node == null) {
            return;
        }
        //先中序遍历左子树
        inorderTraversal(node.left);
        //输出根节点
        System.out.println(node.element);
        //再中序遍历右子树
        inorderTraversal(node.right);
    }

    /**
     * 后序遍历
     */
    public void postorderTraversal() {
        postorderTraversal(root);
    }

    private void postorderTraversal(Node<E> node) {
        if (node == null) {
            return;
        }
        //先遍历左子树
        postorderTraversal(node.left);
        //再遍历右子树
        postorderTraversal(node.right);
        //最后访问根节点
        System.out.println(node.element);
    }

    /**
     * 层序遍历
     */
    public void levelOrderTranversal() {
        if (root == null) {
            return;
        }
        Queue<Node<E>> queue = new LinkedList<>();
        //将头节点入队
        queue.offer(root);
        while (!queue.isEmpty()) {
            //将头结点出队
            Node<E> node = queue.poll();
            System.out.println(node.element);
            //如果左子节点不为空，就将左子节点入队
            if (node.left != null) {
                queue.offer(node.left);
            }
            //如果右子节点不为空，就将右子节点入队
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }

}

BBST类

package cn.xx.java.tree;

import java.util.Comparator;

/**
 * @author xiexu
 * @create 2021-08-09 4:27 下午
 */
public class BBST<E> extends BST<E> {

    public BBST() {
        this(null);
    }

    public BBST(Comparator<E> comparator) {
        super(comparator);
    }

    /**
     * 左旋
     *
     * @param grand
     */
    protected void rotateLeft(Node<E> grand) {
        Node<E> parent = grand.right;
        Node<E> child = parent.left;
        grand.right = child;
        parent.left = grand;
        afterRotate(grand, parent, child);
    }

    /**
     * 右旋
     *
     * @param grand
     */
    protected void rotateRight(Node<E> grand) {
        Node<E> parent = grand.left;
        Node<E> child = parent.right;
        grand.left = child;
        parent.right = grand;
        afterRotate(grand, parent, child);
    }

    /**
     * 公共代码：不管是左旋转、右旋转，都要执行
     *
     * @param grand  失衡节点
     * @param parent
     * @param child
     */
    protected void afterRotate(Node<E> grand, Node<E> parent, Node<E> child) {
        //让parent成为子树的根节点
        parent.parent = grand.parent;
        if (grand.isLeftChild()) {
            grand.parent.left = parent;
        } else if (grand.isRightChild()) {
            grand.parent.right = parent;
        } else { //grand是根节点
            root = parent;
        }

        //更新child的parent
        if (child != null) {
            child.parent = grand;
        }

        //更新grand的parent
        grand.parent = parent;
    }

    /**
     * 统一旋转代码
     *
     * @param r
     * @param a
     * @param b
     * @param c
     * @param d
     * @param e
     * @param f
     * @param g
     */
    protected void rotate(
            Node<E> r, //子树的根节点
            Node<E> a, Node<E> b, Node<E> c,
            Node<E> d,
            Node<E> e, Node<E> f, Node<E> g) {
        //让d成为这棵子树的根节点
        d.parent = r.parent;
        if (r.isLeftChild()) { // r是父节点的左子节点
            r.parent.left = d;
        } else if (r.isRightChild()) { // r是父节点的右子节点
            r.parent.right = d;
        } else { // r是根节点
            root = d;
        }

        // a - b - c
        b.left = a;
        if (a != null) {
            a.parent = b;
        }
        b.right = c;
        if (c != null) {
            c.parent = b;
        }

        // e - f - g
        f.left = e;
        if (e != null) {
            e.parent = f;
        }
        f.right = g;
        if (g != null) {
            g.parent = f;
        }

        // b - d - f
        d.left = b;
        d.right = f;
        b.parent = d;
        f.parent = d;
    }

}

RBTree类

package cn.xx.java.tree;

import java.util.Comparator;

/**
 * @author xiexu
 * @create 2021-08-09 9:24 上午
 */
public class RBTree<E> extends BBST<E> {
    private static final boolean RED = false;
    private static final boolean BLACK = true;

    public RBTree() {
        this(null);
    }

    public RBTree(Comparator<E> comparator) {
        super(comparator);
    }

    /**
     * 添加节点之后的操作
     *
     * @param node 新添加的节点
     */
    @Override
    protected void afterAdd(Node<E> node) {
        Node<E> parent = node.parent;

        //添加的是根节点或者上溢到达了根节点
        if (parent == null) {
            black(node); //直接将根节点染成黑色
            return;
        }

        //如果父节点是黑色，则直接返回
        if (isBlack(parent)) {
            return;
        }

        //uncle节点
        Node<E> uncle = parent.sibling();
        //grand节点
        Node<E> grand = parent.parent;

        //uncle节点是红色[B树节点上溢]
        if (isRed(uncle)) {
            black(parent);
            black(uncle);
            red(grand);
            //grand节点当做是新添加的节点
            afterAdd(grand);
            return;
        }

        //uncle节点不是红色
        if (parent.isLeftChild()) { //L
            if (node.isLeftChild()) { //LL
                black(parent);
                red(grand);
                rotateRight(grand); //右旋
            } else { //LR
                black(node);
                red(grand);
                rotateLeft(parent); //左旋
                rotateRight(grand); //右旋
            }
        } else { //R
            if (node.isLeftChild()) { //RL
                black(node);
                red(grand);
                rotateRight(parent); //右旋
                rotateLeft(grand); //左旋
            } else { //RR
                black(parent);
                red(grand);
                rotateLeft(grand); //左旋
            }
        }
    }

    /**
     * 给节点染色
     *
     * @param node
     * @param color
     * @return
     */
    private Node<E> color(Node<E> node, boolean color) {
        if (node == null) {
            return node;
        }
        ((RBNode<E>) node).color = color;
        return node;
    }

    /**
     * 把节点染成红色
     *
     * @param node
     * @return
     */
    private Node<E> red(Node<E> node) {
        return color(node, RED);
    }

    /**
     * 把节点染成黑色
     *
     * @param node
     * @return
     */
    private Node<E> black(Node<E> node) {
        return color(node, BLACK);
    }

    /**
     * 判断当前节点是什么颜色的
     * 空节点默认是黑色
     *
     * @param node
     * @return
     */
    private boolean colorOf(Node<E> node) {
        return node == null ? BLACK : ((RBNode<E>) node).color;
    }

    /**
     * 当前节点是否为黑色
     *
     * @param node
     * @return
     */
    private boolean isBlack(Node<E> node) {
        return colorOf(node) == BLACK;
    }

    /**
     * 当前节点是否为红色
     *
     * @param node
     * @return
     */
    private boolean isRed(Node<E> node) {
        return colorOf(node) == RED;
    }

    /**
     * 重写父类中的createNode方法
     *
     * @param element
     * @param parent
     * @return
     */
    @Override
    protected Node<E> createNode(E element, Node<E> parent) {
        return new RBNode<>(element, parent);
    }

    /**
     * 删除节点之后的操作
     *
     * @param node 被删除的节点 或者 用以取代被删除节点的子节点（当被删除节点的度为1）
     */
    @Override
    protected void afterRemove(Node<E> node) {

        //如果删除的节点是红色 或者 用以取代删除节点的子节点是红色
        if (isRed(node)) {
            black(node);
            return;
        }

        //parent节点
        Node<E> parent = node.parent;

        //删除的是根节点
        if (parent == null) {
            return;
        }

        //删除的是黑色叶子节点[下溢]
        //判断被删除的node是左还是右，因为被删除后该父节点的一边就会为空，所以兄弟节点就在另一边
        boolean left = parent.left == null || node.isLeftChild();
        Node<E> sibling = left ? parent.right : parent.left;
        if (left) { //被删除的节点在左边，兄弟节点在右边
            if (isRed(sibling)) { //兄弟节点是红色
                black(sibling); //兄弟节点染成黑色
                red(parent); //parent节点染成红色
                rotateLeft(parent); //右旋
                //更换兄弟
                sibling = parent.right;
            }

            //兄弟节点必然是黑色
            //如果左右节点为null，null也是黑色
            if (isBlack(sibling.left) && isBlack(sibling.right)) {
                //兄弟节点没有一个红色子节点，父节点要向下跟兄弟节点合并
                boolean parentBlack = isBlack(parent); //处理之前先检查下父节点是不是黑色
                black(parent);
                red(sibling);
                if (parentBlack) {
                    //只需把 parent 当做被删除的节点处理即可
                    afterRemove(parent);
                }
            } else { //兄弟节点至少有1个红色子节点，向兄弟节点借元素
                //兄弟节点的右边是黑色，要对兄弟节点进行左旋转
                if (isBlack(sibling.right)) {
                    rotateRight(sibling);
                    sibling = parent.right; //兄弟节点要重新赋值
                }

                //sibling继承parent的颜色
                color(sibling, colorOf(parent));
                black(sibling.right);
                black(parent);

                rotateLeft(parent);
            }
        } else { //被删除的节点在右边，兄弟节点在左边

            if (isRed(sibling)) { //兄弟节点是红色
                black(sibling); //兄弟节点染成黑色
                red(parent); //parent节点染成红色
                rotateRight(parent); //右旋
                //更换兄弟
                sibling = parent.left;
            }

            //兄弟节点必然是黑色
            //如果左右节点为null，null也是黑色
            if (isBlack(sibling.left) && isBlack(sibling.right)) {
                //兄弟节点没有一个红色子节点，父节点要向下跟兄弟节点合并
                boolean parentBlack = isBlack(parent); //处理之前先检查下父节点是不是黑色
                black(parent);
                red(sibling);
                if (parentBlack) {
                    //只需把 parent 当做被删除的节点处理即可
                    afterRemove(parent);
                }
            } else { //兄弟节点至少有1个红色子节点，向兄弟节点借元素
                //兄弟节点的左边是黑色，要对兄弟节点进行左旋转
                if (isBlack(sibling.left)) {
                    rotateLeft(sibling);
                    sibling = parent.left; //兄弟节点要重新赋值
                }

                //sibling继承parent的颜色
                color(sibling, colorOf(parent));
                black(sibling.left);
                black(parent);

                rotateRight(parent);
            }
        }
    }

    /**
     * 红黑树节点
     *
     * @param <E>
     */
    private static class RBNode<E> extends Node<E> {

        //建议新添加的节点默认为 RED，
        //这样能够让红黑树的性质尽快满足（性质 1、2、3、5 都满足，性质 4 不一定）
        boolean color = RED;

        public RBNode(E element, Node<E> parent) {
            super(element, parent);
        }

        @Override
        public String toString() {
            String str = "";
            if (color == RED) {
                str = "R_";
            }
            return str + element.toString();
        }
    }

}
猿小羽
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
红黑树（Red Black Tree）
02-13
红黑树（Red Black Tree）是一种自平衡二叉查找树，由计算机科学家Rudolf Bayer在1972年提出。这种数据结构在现代计算机科学中广泛应用，特别是在各种需要高效查找、插入和删除操作的场景中。红黑树的主要特点是通过...
redblack tree 红黑树代码
12-19
红黑树C语言代码： #include "redblack.h" #include #include "fatal.h" 头文件： #include #include "fatal.h" typedef int ElementType; #define NegInfinity (-10000) #ifndef _RedBlack_H #define _Red...
红黑树与2-3树的等价性->深入理解红黑树
z13192905903的博客
11-14 438
2-3树定义 节点可以存放一个或者两个元素,称为2节点和3节点(这也是2-3树名称的由来),如下图 是一棵绝对平衡的二插树,下图示例就是一个2-3树 任意一个节点到叶子节点的深度是一致的 满足二分搜索树的基本性质,即 中序遍历的结果是有序 二节点 -> 左节点<中间节点<右节点,如图中的以52为根节点的子树 三节点 -> 左节点<中左节点<中间节点&...
动画 | 什么是红黑树？（与2-3-4树等价）
终极冥帝
01-23 119
二分搜索树是为了快速查找而生，它是一颗二叉树，每一个节点只有一个元素（值或键值对），左子树所有节点的值均小于父节点的值，右子树所有的值均大于父节点的值，左右子树也是一颗二分搜索树，而且没有键值相等的节点。它的查找、插入和删除的时间复杂度都与树高成比例，期望值是O(log n)。 但是插入数组如[]，二分搜索树的缺点就暴露出来了，二分搜索树退化成线性表，查找的时间复杂度达到最坏时间复杂度O...
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 18万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
红黑树介绍
mz474920631的博客
05-28 4万+
红黑树一、红黑树的概念红黑树的性质红黑树节点的定义红黑树结构二、使用步骤1.引入库2.读入数据总结 一、红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质 每个结点不是红色就是黑色 根节点是黑色的 如果一个节点是红色的，则它的两个孩子结点是黑色的 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数
红黑树(Red Black Tree)详解
wenkezhuangyuan的博客
08-04 1644
红黑树 红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 红黑树是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑树”。 红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性..
JS 实现红黑树（Red Black Tree）
三月的船长
10-08 1065
多的不说，算法导论，推荐一波。如果想学会红黑树这种实现逻辑比较复杂，看书是必要的，书的知识体系比较健全，讲解也是循序渐进，当你尝试过自己实现红黑树，又看过其他讲解红黑树博客，再回过头来看书，很多疑问就迎刃而解了。
手撕红黑树RedBlackTree Right？带动画的哦
weixin_43272605的博客
02-20 2万+
首先这篇博客花了一点时间才总结出来，肯定还有错误，希望各位读者能够小心翼翼的看。尽量理解吧，因为我自己水平也很菜哈哈。 首先红黑树是一个二叉查找树，就是加了各种限制，让他成为了一种自平衡的二叉树。首先来看看它的五大特性，这也是我们必须要牢记的，后面多次提到，但我还是会多次重复。 GO????黑????GO 树的节点要么是红色的，要么就是黑色的（这是废话，不然怎么叫红黑树） 树的根节点一定是黑色的 ...
红黑树Red/Black Tree
JZ
09-30 1万+
红黑树Red/Black Tree 建立二进制搜索树，我们得到红/黑树，旨在解决BST可能变得不平衡的问题。（BST【二叉搜索树】，是对于任意的node x，如果node y是node x的左边的节点, 那么Key(y) &lt;= Key(x); 对于任意的node x， 如果node y 是node x的右边的节点， 那么key(y)&gt;=key(x).） 红色/黑色树的简短版本是它是...
RBT.rar_red black tree_红黑树
09-24
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家鲁道夫·贝尔在1978年提出。它在保持二叉查找树特性的同时，通过引入颜色属性来确保树的平衡，从而提高数据操作的效率。在C++中实现红黑树，通常...
rbt.rar_rbt_red black tree_动态演示_红黑树
09-14
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家Rudolf Bayer于1972年提出。它在保持了二叉查找树基本特性的同时，通过额外的颜色属性实现了高效的插入、删除和查找操作。红黑树的名字来源于它的...
redblacktree_roundu2g_红黑树_
10-02
总的来说，"redblacktree_roundu2g"提供了一个基础的红黑树实现，允许开发者理解并应用这种高效的数据结构。通过学习和使用这个实现，可以深入了解红黑树的工作原理，并将这些知识应用于实际的软件开发中，例如在...
【C++】B树及其实现
lgr669877aqa的博客
07-06 837
为了方便学习，我们在这里先将m设为3，这时每个结点能存2个关键字和3个孩子。不过为了方便后续插入，分别额外多开了一个空间。K _keys[M];// 用于存储关键字// 用于存储孩子size_t _n;// 存储当前孩子的数量i < M;++i)_n = 0;B树：有序数组+平衡多叉树；B+树：有序数组链表+平衡多叉树；B*树：一棵更丰满的，空间利用率更高的B+树。
B+树的元素检索过程
wdwwx的博客
07-04 354
B+树的设计使得每次查找的时间复杂度为 O(log n)，其中 n 是树中节点的数量。这是因为 B+树是一种平衡树，每个节点拥有多个子节点，从而减少了树的高度，加快了查找速度。在每个非叶子节点中，根据节点内部存储的索引键（或者范围）来决定接下来搜索的路径。总结来说，B+树的检索方式是通过多路搜索，利用节点内部的索引信息，逐层向下遍历直到叶子节点，然后在叶子节点中进行具体的数据匹配操作。B+树的检索方式主要是通过从根节点开始逐层向下搜索，直到找到目标数据或确定目标数据不存在为止。
RGB树-美团2023笔试(codefun2000)
lulutoy的博客
07-07 394
今天，他来到了道成林，这是一片美丽而神秘的森林。在探险途中，他遇到了一棵 n 个节点的树，树上每个节点都被涂上了红、绿、蓝三种颜色之一。塔子哥发现，如果这棵树同时存在一个红色节点、一个绿色节点和一个蓝色节点，那么我们就称这棵树是多彩的。但是，在探险的过程中，塔子哥发现这棵树上有一条边非常重要，如果砍掉这条边，就可以把这棵树分成两个部分。他想知道，有多少种砍法可以砍掉这条边，使得砍完之后形成的两棵树都是多彩的。其中 R 表示红色， G 表示绿色， B 表示蓝色。输出一行，一个正整数，表示答案。
【数据基础】— B树
最新发布
深耕AI领域，专注中、高人工智能领域发展；同步研究电磁学及超导材料、量子力学；关注能源发展和技术，同时进行医学创新
07-09 411
B+树（B+ Tree）是一种自平衡的树状数据结构，它是B树（B-Tree）的一种变体，但在结构上进行了优化，特别适用于数据库和操作系统的文件系统中。B+树的所有数据都存储在叶子节点中，且叶子节点之间通过指针相连形成链表，这使得它在进行范围查询和顺序访问时非常高效。
红黑树的插入详细图解，直接拿下红黑树
08-17
红黑树（Red Black Tree）是一种自平衡的二叉查找树，广泛应用于计算机科学中的数据结构，特别适用于实现关联数组。它于1972年由Rudolf Bayer首次发明，并在1978年被Leo J. Guibas和Robert Sedgewick修改成如今的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

猿小羽

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

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

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

打赏作者

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

抵扣说明：

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

余额充值