手写红黑树

最新推荐文章于 2024-11-15 20:51:51 发布
最新推荐文章于 2024-11-15 20:51:51 发布
阅读量336 收藏 7
点赞数 9
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45104798/article/details/135684116
版权

概念：

二叉树：每个节点最多只能有2个子节点。

                叶子节点：没有子节点的节点。

二叉搜索树：左节点小于父节点，父节点小于有节点（便于查找）

        中序遍历：左节点--> 中(根)节点 --> 右节点（结果是从小到大的顺序）

        缺点：极端情况下会变成线性链表，效率底下。

平衡树（AVL树）：避免二叉搜索树的致命缺点。

        具有二叉搜索树的全部特点

        每个节点的左子树和右子树的高度相差最多为1

        缺点：会频繁的左右旋。

红黑树：并不是一个完美的平衡二叉搜索树

性质 每个节点要么是黑色要么是红色

        根节点是黑色

        每个叶子节点是黑色

        每个红色节点的两个子节点一定都是黑色

        任意一个节点到每个叶子节点的路径都包含相同数量的黑色节点。

                如果一个节点存在黑子节点，那么该节点肯定有两个子节点

变色：节点的颜色由红变黑，由黑变红。

左旋：以某个节点作为支点(旋转节点)，其右子节点变为旋转节点的父节点，右子节点的左子节点变为旋转节点的右子节点，左子节点保持不变。

右旋：以某个节点作为支点(旋转节点)，其左子结点变为旋转节点的父节点，左子节点的右子节点变为旋转节点的左子节点，右子节点保持不变。

插入

新插入的节点是红色(根节点是黑节点)。插入相同的值执行覆盖更新操作。

插入节点的父节点是黑色，直接插，不会影响平衡。

插入节点的父节点是红色，且叔叔节点是红色 ---》

父节点和叔叔节点变为黑色，父父节点变为红色，以爷爷为当前节点，继续操作，直到完成平衡

插入节点的的父节点是红色且叔叔节点不存在，或者为黑色，并且插入节点的父节点是父父节点的左子节点，且插入的节点是左子节点(LL双红)---》

将父节点变为黑色，父父节点变为红色并且对父父节点右旋。

插入节点的父节点是红色且叔叔节点不存在，或者为黑色，并且插入节点的父节点是父父节点的左子节点，且插入的节点是右子节点(LR双红)---》

父节点左旋得到LL双红，处理LL双红。

插入节点的父节点是红色且叔叔节点不存在，或者为黑色，并且插入节点的父节点是父父节点的右子节点，且插入的节点是右子节点(RR双红)---》

父节点变黑，父父节点变红，左旋父父节点

插入节点的父节点是红色且叔叔节点不存在，或者为黑色，并且插入节点的父节点是父父节点的右子节点，且插入的节点是左子节点(RL双红)---》

父节点右旋，处理RR双红。

手写红黑树：删除、打印方法后续补充

package RBTree;

public class RBTree {

    // 根节点
    private RBNode root;

    static class RBNode<V extends Comparable> {
        private V value;
        private RBNode<V> parent;
        private RBNode<V> left;
        private RBNode<V> right;
        private boolean isRed;

        public RBNode() {
        }

        public V getValue() {
            return value;
        }

        public void setValue(V value) {
            this.value = value;
        }

        public RBNode<V> getParent() {
            return parent;
        }

        public void setParent(RBNode<V> parent) {
            this.parent = parent;
        }

        public RBNode<V> getLeft() {
            return left;
        }

        public void setLeft(RBNode<V> left) {
            this.left = left;
        }

        public RBNode<V> getRight() {
            return right;
        }

        public void setRight(RBNode<V> right) {
            this.right = right;
        }

        public boolean isRed() {
            return isRed;
        }

        public void setRed(boolean red) {
            isRed = red;
        }
    }

    /**
     * 获取当前节点的父节点
     * @param node
     * @return
     */
    public RBNode getParent(RBNode node) {
        if(node != null){
            return node.getParent();
        }
        return null;
    }

    /**
     * 获取当前节点的左子节点
     * @param node
     * @return
     */
    public RBNode getChildLeft(RBNode node){
        if(node != null){
            return node.getLeft();
        }
        return null;
    }

    /**
     * 获取节点的右子节点
     * @param node
     * @return
     */
    public RBNode getChildRight(RBNode node){
        if(node != null){
            return node.getRight();
        }
        return null;
    }

    /**
     * 获取当前节点颜色
     * @param node
     * @return true:红色 false:黑色
     */
    public boolean getColor(RBNode node){
        if (node != null){
            return node.isRed();
        }
        throw new RuntimeException("node is null");
    }

    /**
     * 设置节点颜色
     * @param node
     * @param isRed true:红色 false:黑色
     */
    public void setColor(RBNode node, boolean isRed){
        if (node != null){
            node.setRed(isRed);
        }
    }

    /**
     * 中序遍历
     * @param node
     */
    public void printTree(RBNode node){
        if (node != null){
            printTree(node.getLeft());
            System.out.println(node.getValue());
            printTree(node.getRight());
        }
    }

    // 左旋:该点右子节点变为父节点，该点右子节点的左子节点变为该节点右子节点
    public void leftRotate(RBNode node){
        if (node != null){
            Comparable value = node.getValue();
            RBNode parent = node.getParent();
            RBNode right = node.getRight();
            RBNode rightChildLeft = right.getLeft();
            Comparable parentLeftChildValue = parent.getLeft().getValue();
            Comparable parentRightChildValue = parent.getRight().getValue();

            if(value.compareTo(parentLeftChildValue) == 0){
                parent.setLeft(right);
            }
            if(value.compareTo(parentRightChildValue) == 0){
                parent.setRight(right);
            }
            right.setParent(parent);

            node.setRight(rightChildLeft);
            rightChildLeft.setParent(node);

            right.setLeft(node);
            node.setParent(right);
        }
    }

    // 右旋:该节点左子节点变为父节点，该节点左子节点的右子节点变为该节点左子节点
    public void rightRotate(RBNode node){
        if (node != null){
            Comparable value = node.getValue();
            RBNode parent = node.getParent();
            RBNode left = node.getLeft();
            RBNode leftChildRight = left.getRight();
            Comparable parentLeftChildValue = parent.getLeft().getValue();
            Comparable parentRightChildValue = parent.getRight().getValue();

            if(value.compareTo(parentLeftChildValue) == 0){
                parent.setLeft(left);
            }
            if(value.compareTo(parentRightChildValue) == 0){
                parent.setRight(left);
            }
            left.setParent(parent);

            left.setParent(node);
            node.setParent(left);

            node.setLeft(leftChildRight);
            leftChildRight.setParent(node);
        }
    }

    // 插入：找父节点
    public void insert(RBNode node){
        RBNode parent = null;
        RBNode tempParent = root;

        while (tempParent != null){
            parent = tempParent;
            int cmp = node.getValue().compareTo(parent.getValue());
            if(cmp > 0){
                // node > parent
                tempParent = parent.getRight();
            }else if(cmp > 0){
                // node < parent
                tempParent = parent.getLeft();
            }else{
                tempParent.setValue(node.getValue());
                return;
            }
        }
        if(root == null){
            node.parent = null;
            root = node;
            return;
        }else {
            node.setParent(parent);
        }

        // 判断作为左子节点还是右子节点
        int cmp = node.getValue().compareTo(parent.getValue());
        if(cmp > 0){
            parent.setRight(node);
        }else if(cmp < 0){
            parent.setLeft(node);
        }

        // 修复红黑树的平衡
        fixBalance(node);
    }

    /**
     * 插入后修复红黑树的平衡
     * 情景1: 红黑树为空树，将跟节点染色为黑色
     *  XXX情景2: 插入节点的key已经存在，替换已在插入完成，此处不需要处理
     *  XXX情景3: 插入节点的父节点为黑色，不影响红黑树的特性，所以红黑树依然平衡，所以不需要处理。
     * 情景4需要咱们去处理
     * |---情景4:     插入节点的父节点为红色
     * |---情景4.1:   叔叔节点存在，并且为红色(父-叔 双红)
     * |---情景4.2:   叔叔节点不存在，或者为黑色，父节点为爷爷节点的左子树
     * |---情景4.2.1: 插入节点为其父节点的左子节点(LL情况)
     * |---情景4.2.2: 插入节点为其父节点的右子节点(LR情况)
     * |---情景4.3:   叔叔节点不存在，或者为黑色，父节点为爷爷节点的右子树
     * |---情景4.3.1: 插入节点为其父节点的右子节点( RR情况)
     * |---情景4.3.2: 插入节点为其父节点的左子节点(RL情况)
     */
    public void fixBalance(RBNode node){

        if(node.parent == null){
            // 情景1
            node.setRed(false);
        }else if (node.parent.isRed == false){
            // 情景3
        }else {
            // 情景4
            RBNode parent = node.getParent();
            RBNode grandParent = parent.getParent();
            RBNode uncle;
            if (parent == grandParent.left){
                uncle = grandParent.getRight();
                if(uncle != null && uncle.isRed()){
                    // 情景4.1
                    setColor(parent, false);
                    setColor(uncle, false);
                    setColor(grandParent, true);
                    fixBalance(grandParent);
                    return;
                }else {
                    if(node == parent.left){
                        //  情景4.2.1
                        setColor(parent, false);
                        setColor(grandParent, true);
                        rightRotate(grandParent);
                        return;
                    }else if (node == parent.right){
                        // 情景4.2.2
                        leftRotate(parent);
                        fixBalance(parent);
                        return;
                    }
                }
            }else if (parent == grandParent.right){
                uncle = grandParent.getLeft();
                if(uncle != null && uncle.isRed()){
                    // 情景4.1
                    setColor(parent, false);
                    setColor(uncle, false);
                    setColor(grandParent, true);
                    fixBalance(grandParent);
                    return;
                }else {
                    if(node == parent.right){
                        //  情景4.3.1
                        setColor(parent, false);
                        setColor(grandParent, true);
                        leftRotate(grandParent);
                        return;
                    }
                    if (node == parent.left){
                        // 情景4.3.2
                        rightRotate(parent);
                        fixBalance(parent);
                        return;
                    }
                }
            }
        }
    }
}

byydzj
关注
专栏目录
【动态图文详解-史上最易懂的红黑树讲解】手写红黑树（Red Black Tree）
AI天才研究院
12-10 1万+
红黑树：一棵自平衡（AVL）+二叉查找树(BST)什么是红黑树红黑树，Red-Black Tree 「RBT」是一个自平衡(不是绝对的平衡)的二叉查找树(BST)。红黑树是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑...
数据结构系列之Java手写实现红黑树
Nicky's blog
08-18 2717
数据结构系列之Java手写实现红黑树，红黑树是一种自平衡的二叉搜索树，是二叉搜索树的拓展。红黑树只有两种节点，一种是红色的，一种是黑色的。红黑树不像AVL树那样严格，而是近似平衡。
手写红黑树【数据结构】
小心星的博客
03-30 1019
手写红黑树【数据结构】
JAVA手写红黑树
瑞文のBlog
01-13 852
既然我们需要手写红黑树，那么我们能就要高清书什么是红黑树 红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机与科学用到的一种数据结构，典型的用途是实现关联数组 基本特征 每个节点不是红色就是黑色 不可能有连在一起的红色节点 根节点都是黑色 每个红色节点的两个子节点都是黑色 接下我我们欣赏一颗红黑树 红黑树变换规则： 改变节点颜色 左旋转 右旋转 变色 适用于： 当前父节点是红色且他的祖父节点（父亲的父亲）的另一个子节点也是红色（叔叔节点） 规则： 将父亲节点设置为黑色
C语言-手写红黑树
weixin_45203607的博客
09-02 397
C语言-手写红黑树
java手写红黑树_手写红黑树的简单实现
weixin_33910191的博客
02-27 330
基于《算法》一书的红黑树的插入和删除。看过不同的教材，也有不同的实现方式，但是最终的结果也大致相同，感觉这个比较容易理解，就采用这种的方式来进行简单实现。定义树节点的实体类型private static final boolean RED = true;private static final boolean BLACK = false;/*** 红黑树的节点结构* 保存的值，左节点，右节点以及颜...
TypeScript手写红黑树
wangzi95211的博客
02-20 211
使用TypeScript手写一个红黑树，具体的思路步骤可以边看代码边看解析。 一. 实现步骤分析 实现一个 TypeScript 红黑树的详细步骤： 定义红黑树的节点：定义一个带有键、值、颜色、左子节点、右子节点和父节点的类；实现左旋操作：将一个节点向左旋转，保持红黑树的性质；实现右旋操作：将一个节点向右旋转，保持红黑树的性质；实现插入操作：在红黑树中插入一个新的节点，并保持红黑树的性质；实现删除操作：从红黑树中删除一个节点，并保持红黑树的性质；实现修复红黑树性质：在插入或删除操作后，通过旋转和变色
数据结构-二叉树及其遍历
宁zz的博客
11-15 536
本篇文章咱们聊聊数据结构中的树，准确的说因该是只说一说二叉树以及相关的三种递归遍历、三种非递归遍历以及层次遍历。🍃二叉树 (BinaryTree) 是 n (n>0) 个结点所构成的集合，它或为空树(n-0)或为非空树，对于非空树(1) 有且仅有一个称之为根的结点:(2) 除根结点以外的其余结点分为两个互不相交的子集 TI 和 T2，分别称为 T 的左子树和右子树，且 T1 和 T2 本身又都是二叉树。🍃二叉树与树一样具有递归性质，二叉树与树的区别。
数据结构-线性表-具有独立头节点的双向循环链表
最新发布
2301_76819732的博客
11-15 529
双向循环链表是一种在链表基础上拓展而来的数据结构。与普通链表不同的是，它的每个节点都有两个指针，一个指向前驱节点（prior），一个指向后继节点（next而且，它是循环的，即链表的尾节点的后继指针指向头节点，头节点的前驱指针指向尾节点，形成一个闭合的环。我们这里讨论的双向循环链表还有一个独立的头节点。这个独立头节点不存储数据，主要用于方便对链表的操作和维护。这种链表为空的条件是头节点的next和prior指针都指向NULL。在代码中，首先定义了链表节点的数据类型。} Node;这里，
数据结构——重排链表（经典题目，涉及三个知识点）
vavid的专栏
11-15 258
算法思想：将链表分成两半来处理，前半部分，和后半部分；针对后半部分进行逆序，再从前半部分和逆序后的后半部分分别取一个结点组成一个新的链表。本文采用的正向遍历，前面文章采用的递归，都要掌握。3、合并前半段链表和后半段链表。，采用了快慢指针的算法。
数据结构 ——— 层序遍历链式二叉树
weixin_55341642的博客
11-13 601
利用队列先进先出的性质实现层序遍历链式二叉树
【数据结构初阶】栈和队列的建立
twlw13的博客
11-15 697
是一种特殊的，它只允许一端进行操作，这一端被称为则另一端被称为而栈内的数据遵循后进后出，先进后出栈的插入操作被称为插入的数据在栈顶栈的删除操作被称为删除的数据也在栈顶那我们要如何实现栈这个特殊的线性表呢？在前面我们学过顺序表和链表，而栈的实现也可以使用顺序表或者链表来实现，那使用哪一种更好呢？用顺序表来实现栈本质上就是，根据栈的特性：后进后出，先进后出可知，而使用链表实现栈，则最好是，进行，但使用链表需要用到指针会比使用数组麻烦很多，所以我们大多数时候使用数组来实现栈，但链表也是可以的，
数据结构-二叉搜索树（Java语言）
NoobNo2的博客
11-15 754
个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即。在最后删除target节点的时候，要判断target节点是在targetparent的左边还是右边。同时用parent节点记录cur的父节点，最终用parent的val与key作比较，，用它的值填补到被删除节点中，再来处理该结点的删除问题。如果cur节点val==key，返回该节点。
排序算法 -归并排序
qq_46538985的博客
11-15 716
归并排序
LeetCode:215. 数组中的第K个最大元素
m0_75035023的博客
11-11 330
LeetCode:215. 数组中的第K个最大元素,数据结构与算法
【数据结构】【线性表】静态链表(附C语言源码)
weixin_58498967的博客
11-15 140
一段连续的空间，用数组下标去代替指针有天然的优势。和其他的链表相比，静态链表最重要的特点就是结点的结构体指针换成了整型变量。其实很简单，因为这里的整型变量表示的是结构体数组的下标，下标要是非负数才有实际意义，因此我们可以用负数去表示指针的NULL。链表是物理结构为链式的线性表，其每个结点的存储位置不一定是连续的，每个结点依靠结点元素的中的指针线性相连。但有时候为了方便管理内存空间，会将链表的各个结点存储空间放在一块，其实现方式类似于数组，只不过由传统的数据类型改为结构体类型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值