数据结构-手撕红黑树

最新推荐文章于 2023-03-30 21:04:39 发布
原创 最新推荐文章于 2023-03-30 21:04:39 发布 · 326 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

手撕红黑树

1. 红黑树的性值

1.1 平衡条件

在这里插入图片描述

  1. 每个节点非黑即红
  2. 根节点是黑色
  3. 叶节点（NIL）是黑色
  4. 如果一个节点是红色，则它的两个子节点都是黑色
  5. 从任意节点出发到所有叶节点路径上，黑色节点数量相同

1.2最长路径和最短路径长度关系？

根据平衡条件第4、5点，最短路径都是黑色；最长路径红黑相间；最长是最短的两倍；

1.3平衡调整的终极法门

插入调整站在祖父节点看

删除调整站在父节点看

插入和删除的情况处理一共五种

1.4新插入的节点的颜色

红色，因为插入黑色会引发失衡；插入红色不一定会失衡。

2. 红黑树的插入

2.1 调整原则

为了不影响整颗树的平衡， 调整前路径上的黑节点数量等于调整后路径上黑色节点数量

2.2 调整目的

消除双红

2.3 调整方法

情况一：uncle为红色

站在15节点向下看，发现右子树为红色，并且右子树有一个红色的子节点 ==》 失衡
在这里插入图片描述
调整方法：

  • 15节点 ==》 变红

  • 1节点 ==》 变黑

  • 20节点 ==》 变黑

情况二：uncle为黑色

站在20节点向下看，左侧节点为红色，并且左侧节点的孩子有红色节点 ==》失衡
在这里插入图片描述
类似于AVL树的LL失衡调整 ==> 右旋
在这里插入图片描述
调整后的变色方案可以选择红色上浮或下沉

红色上浮：
在这里插入图片描述
红色下沉：

在这里插入图片描述

3. 红黑树的删除

3.1 删除场景

  • 场景1： 删除度为0的红色节点： 直接删除即可，不会引发失衡
    在这里插入图片描述

  • 场景2：删除度为1的红色节点：不存在这样的节点

若一个红色节点下面有子节点，一定同时有两个黑色子节点
原因：红黑树的第4条和第5条性值
性值4： 如果一个节点是红色，则它的两个子节点都是黑色
性值5： 从任一节点出发到所有叶节点路径上，黑色节点数量相同

  • 场景3（需要调整）： 删除度为0的黑色节点
    在这里插入图片描述

删除X后，因X度为0，其下只有NIL节点；
红色根节点左子树一共两个黑色节点（包含NIL节点）；所以该红色根节点右子树也需要有两个黑色节点 ==>
即，将该度为0 的黑色节点的颜色加到NIL节点上，至此，这个NIL节点变为双重黑
删除调整的目的就是为了消除双重黑节点。

  • 场景4： 删除度为1的黑色节点
    度为1的黑色节点的唯一子孩子一定是红色的，如下图所示：
    在这里插入图片描述
    删除X，将唯一子节点挂到父节点，将当前节点X的黑色加到唯一子孩子上。

3.2 调整场景

场景3中，删除度为0的黑色节点会引发红黑树的失衡，消除的双重黑。

  • 情况一 (双重黑的兄弟节点为黑色)
    双重黑X的兄弟为黑，且兄弟节点的子节点均为黑色节点：
    在这里插入图片描述

调整方法：

  • 双重黑 及 其兄弟节点 --> 去掉一重黑

  • 双重黑的父节点 --> 加一重黑

  • 情况二 RR失衡：双重黑的兄弟节点为黑色， 右子树的右子树为红色：
    双重黑为左子树，双重黑的兄弟节点的右子树为确定性红色（左子树颜色不确定）
    在这里插入图片描述
    若38为红色，则调整前左子树一共有2个黑，则调整后，仍需要为两个黑： 将51改为黑，38 & 72改为红；
    若38为黑色，则调整前左子树一共3个黑，调整后，仍需要为3个黑，将72改为黑。
    总结RR失衡调整策略：大左旋 => 2个子节点改为黑色，一个新根改为原根的颜色。

  • 情况三RL失衡：双重黑的兄弟节点为黑色，右子树的左子树为红色，右子树为黑色
    双重黑为左子树，双重黑的兄弟节点的左子树为红色，右子树为确定性黑色（一旦右子树为红，则为RR失衡）
    在这里插入图片描述
    调整方法：
    step1: 小右旋 => 将原根节点的颜色和新根节点的颜色对调（原根72改为红色，新根51改为黑色），变为情况二，图示 =》
    在这里插入图片描述

step2: 大左旋，即，调整为 =》
在这里插入图片描述

将新根（51）变为原根（38）的颜色
将新根（51）左右子树变为黑色
双重黑变为黑色

  • 情况四： (双重黑的兄弟节点为红色)：
    step1: 根节点改为红色

step2: 情况（1）若 => 双重黑为右子树，根节点的左子树为红色：将该根节点右旋
​ 情况（2）若 => 双重黑为左子树，根节点的右子树为红色：将该根节点左旋
step3: 新根（原红色的兄弟节点）改为黑色
step4: 情况（1）=> 递归到右子树
​ 情况（2）=> 递归到左子树

下面图演示了 ==> 若双重黑为左子树，根节点的右子树为红色的情况
在这里插入图片描述

左旋 =》新根节点改为黑色，原根节点（双重黑的父节点）改为红色
在这里插入图片描述
至此，双重黑X节点的兄弟节点变为黑色，应递归到当前根节点的左子树中继续调整，该调整已经转换为上面的双重黑的兄弟节点为黑色的情况处理

代码：

public class RbTree {
    static Node NIL = new Node(0, 1, null, null);

    static class Node {
        int key;
        int color;//0:red; 1:black; 2:double black
        Node left;
        Node right;

        Node(int key, int color, Node left, Node right) {
            this.key = key;
            this.color = color;
            this.left = left;
            this.right = right;
        }

        Node(int key, int color) {
            this.key = key;
            this.color = color;
            this.left = NIL;
            this.right = NIL;
        }
    }

    Node getNewNode(int key) {
        return new Node(key, 0);
    }

    private Node _insert(Node root, int key) {
        if (root == NIL) return getNewNode(key);
        if (root.key == key) return root;
        if (key < root.key) {
            root.left = _insert(root.left, key);
        } else {
            root.right = _insert(root.right, key);
        }
        return insert_maintain(root);
    }

    private boolean has_red_child(Node root) {
        return root.left.color == 0 || root.right.color == 0;
    }

    private Node insert_maintain(Node root) {
        int flag = 0;
        if (root.left.color == 0 && has_red_child(root.left)) {
            flag = 1;
        }
        if (root.right.color == 0 && has_red_child(root.right)) {
            flag = 2;
        }
        if (flag == 0) {
            return root;
        }
        if (root.left.color == 0 && root.right.color == 0) {
            root.color = 0;
            root.left.color = 1;
            root.right.color = 1;
            return root;
        }
        if (flag == 1) {
            if (root.left.right.color == 0) {
                root.left = left_rotate(root.left);
            }
            root = right_rotate(root);
        } else {
            if (root.right.left.color == 0) {
                root.right = right_rotate(root.right);
            }
            root = left_rotate(root);
        }
        root.color = 0;
        root.left.color = 1;
        root.right.color = 1;
        return root;
    }

    private Node right_rotate(Node root) {
        Node temp = root.left;
        root.left = temp.right;
        temp.right = root;
        return temp;
    }

    private Node left_rotate(Node root) {
        Node temp = root.right;
        root.right = temp.left;
        temp.left = root;
        return temp;
    }

    Node insert(Node root, int key) {
        root = _insert(root, key);
        root.color = 1;
        return root;
    }

    Node _erase(Node root, int key) {
        if (root == null) return root;
        if (key < root.key) {
            root.left = _erase(root.left, key);
        } else if (key > root.key) {
            root.right = _erase(root.right, key);
        } else {
            if (root.left == NIL || root.right == NIL) {
                Node temp = root.left == NIL ? root.right : root.left;
                temp.color += root.color;
                return temp;
            } else {
                Node temp = predecessor(root);
                root.key = temp.key;
                root.left = _erase(root.left, temp.key);
            }
        }
        return erase_maintain(root);
    }

    private Node erase_maintain(Node root) {
        if (root.right.color != 2 && root.left.color != 2) return root;
        //情况四： 双重黑的兄弟节点为红色
        if (has_red_child(root)) {
            int flag = 0;
            root.color = 0;
            if (root.right.color == 0) {
                root = left_rotate(root);
                flag = 1;
            } else {
                root = right_rotate(root);
                flag = 2;
            }
            root.color = 1;
            if (flag == 1) {
                root.left = erase_maintain(root.left);
            } else {
                root.right = erase_maintain(root.right);
            }
            return root;
        }
        //情况一：双重黑的兄弟节点为黑色，且该兄弟节点下无红色节点
        if (root.left.color == 1 && !has_red_child(root.right) || root.right.color == 1 && !has_red_child(root.left)) {
            root.left.color -= 1;
            root.right.color -= 1;
            root.color += 1;
            return root;
        }
        //情况二 & 三：双重黑的兄弟节点为黑色，且该兄弟节点下存在红色节点
        if (root.left.color == 1) {//双重黑为右子树
            root.right.color = 1;//将双重黑节点变为黑色
            //若左子树的左子树为红色 ==> LL失衡
            //否则（若左子树的右子树为黑色，即，红色节点位于左子树的左子树） ==> LR失衡
            if (root.left.left.color != 0) {
                root.left.color = 0;//将左子树原根变红
                root.left = left_rotate(root.left);//将左子树左旋
                root.left.color = 1;//将左子树新根变黑
            }
            root.left.color = root.color;//将左子树小右旋后，将左子树的新根变为原根颜色
            root = right_rotate(root);//将根大右旋
        } else {//双重黑为左子树
            root.left.color = 1;//将双重黑节点变为黑色
            //若右子树的右子树为红色 ==> RR失衡
            //否则（右子树的右子树为黑色，即，红色节点为右子树的左子树） ==> RL失衡
            if (root.right.right.color != 0) {
                root.right.color = 0;//将右子树原根变红
                root.right = right_rotate(root.right);
                root.right.color = 1;//将右子树新根变黑
            }
            root.right.color = root.color;//将右子树小左旋后，将右子树中新的根节点的颜色变为原根节点的颜色
            root = left_rotate(root);//将根大左旋
        }
        //将新根节点的左右子树变为黑色
        root.right.color = 1;
        root.left.color = 1;
        return root;
    }

    private Node predecessor(Node root) {
        Node temp = root.left;
        while (temp.right != NIL) {
            temp = temp.right;
        }
        return temp;
    }

    Node erase(Node root, int key) {
        root = _erase(root, key);
        root.color = 1;
        return root;
    }

    static void outPut(Node root) {
        if (root == NIL) return;
        System.out.println(root.color + ", " + root.key + ", " + root.left.key + ", " + root.right.key);
        outPut(root.left);
        outPut(root.right);
    }

    public static void main(String[] args) {
        RbTree rbTree = new RbTree();
        Node root = NIL;
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter array: ");
        while (true) {
            String[] strings = scanner.nextLine().split(", ");
            for (String string : strings) {
                int key = Integer.parseInt(string);
                root = rbTree.insert(root, key);
                System.out.println("--------AVL tree print-------");
                outPut(root);
                System.out.println();
                System.out.println("--------AVL tree print done -------");
            }
        }
    }

}

测试结果：

Enter array: 
1, 2, 3, 4, 5, 6, 7, 8, 9
--------AVL tree print-------
1, 1, 0, 0

--------AVL tree print done -------
--------AVL tree print-------
1, 1, 0, 2
0, 2, 0, 0

--------AVL tree print done -------
--------AVL tree print-------
1, 2, 1, 3
1, 1, 0, 0
1, 3, 0, 0

--------AVL tree print done -------
--------AVL tree print-------
1, 2, 1, 3
1, 1, 0, 0
1, 3, 0, 4
0, 4, 0, 0

--------AVL tree print done -------
--------AVL tree print-------
1, 2, 1, 4
1, 1, 0, 0
0, 4, 3, 5
1, 3, 0, 0
1, 5, 0, 0

--------AVL tree print done -------
--------AVL tree print-------
1, 2, 1, 4
1, 1, 0, 0
0, 4, 3, 5
1, 3, 0, 0
1, 5, 0, 6
0, 6, 0, 0

--------AVL tree print done -------
--------AVL tree print-------
1, 4, 2, 6
1, 2, 1, 3
1, 1, 0, 0
1, 3, 0, 0
1, 6, 5, 7
1, 5, 0, 0
1, 7, 0, 0

--------AVL tree print done -------
--------AVL tree print-------
1, 4, 2, 6
1, 2, 1, 3
1, 1, 0, 0
1, 3, 0, 0
1, 6, 5, 7
1, 5, 0, 0
1, 7, 0, 8
0, 8, 0, 0

--------AVL tree print done -------
--------AVL tree print-------
1, 4, 2, 6
1, 2, 1, 3
1, 1, 0, 0
1, 3, 0, 0
1, 6, 5, 8
1, 5, 0, 0
0, 8, 7, 9
1, 7, 0, 0
1, 9, 0, 0

--------AVL tree print done -------
数据结构：手撕红黑树(python方式)
Winnie_boy的博客
05-24 1209
前言：不知道同学有没有看完昨天的B树和B+树，虽说那个B+树在面试中很少被要求手写，但是有一个常考的考点，红黑树，可以一个经常被问到的知识噢，那么今天，我就来跟大家一起手撕红黑树！ 红黑树 说到红黑树不得不先提一下AVL树(平衡二叉搜索树)，不了解AVL树的同学可以自行查询相关文献，然后回来以后，请回答我的两个问题： 红黑树和AVL树的区别是什么？ 1.附上红黑颜色属性，通过颜色控制树的平衡 2.相对于AVL树来说，没有那么严格的要求平衡 3.插入和删除的复杂度和次数较AVL来说，跟随着数量节点的增大，越
【数据结构进阶】手撕红黑树
最新发布
2303_79329831的博客
08-01 1494
红黑树的介绍，以及底层代码逻辑和实现。刚刚接触编程的时候就听说有的大厂HR会让手撕红黑树。心中一直对这个数据结构保持着敬畏和向往，今天在将其撕出来后，用本篇博客加以记录，望周知。红黑树的结点包含四个成员变量，模板类型T：可以存储K或者pair类型，便于后期封装；三个指针：分别为指向左孩子结点的指针，指向右孩子结点的指针，指向父结点的指针；最后变量_col：枚举类型，可以存RED和BLACK。
手撕红黑树
qq_33688997的博客
11-18 1998
#include <stdio.h> #include <stdlib.h>typedef struct RBTNode { int key; int black; struct RBTNode *lchild, *rchild; struct RBTNode *father; } RBTNode;RBTNode *NIL;#define lson node->lch
数据结构——手撕红黑树（开肝！）
qq_48201696的博客
08-06 778
数据结构——红黑树（开撕！） 红黑树介绍 在查找算法中，二叉搜索树是一种查找速度非常快的数据结构，平均查找事件复杂度可以达到O(log2(n))但是对于二叉搜索树，其查找性能还是不太稳定,如下面一颗二叉搜索树，如果要查找5这个结点所在的位置，查找过程依然要达到5次，也即线性查找时间，要保证查找速度稳定控制在**O(log2(n))**左右，就需要对这颗二叉搜索树维持平衡，保证其查找速度 所以在二叉搜索树的基础上，有了红黑树这种维护二叉搜索树平衡，保证查找速度保持在对数级别的数据结构，对于红黑树，其结点定义
为什么红黑树的最长路径不超过最短路径的两倍
m0_50170844的博客
03-10 2901
红黑树的性质： 每个节点不是红色就是黑色 根节点为黑色 没有连续的红色节点 对于每个节点，每条路径上的黑色节点数相同 那么为什么当满足以上性质时，就能保证最长路径不超过最短路径的二倍了呢？ 我们分析一下： 最短路径为全黑，最长路径就是红黑节点交替（因为红色节点不能连续），每条路径的黑色节点相同，则最长路径、刚好是最短路径的两倍。 红黑树为什么删除效率高： 红黑树不追求"完全平衡"，即不像AVL那样要求节点的高度差 <= 1，它只要求部分达到平衡，但是提出了为节点增加颜色，红黑是用非严格的平衡来
数据结构_红黑树
u011616934的博客
04-23 604
数据结构_红黑树
手撕红黑树（Red-Black Tree）
林慢慢的博客
07-06 3294
红黑树 （C++实现）
【数据结构与算法】手撕红黑树
pythonxxoo的博客
04-02 934
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 红黑树 定义 动机： 二叉查找树查找、插入、删除最坏情况时间复杂度可能退化为 O(n)。 AVL 树很好的限制了数的高度为 O(logn)，插入、删除、查找的最坏时间复杂度均为 O(logn)；但删除操作最多需要做 O(logn) 次旋转。 红黑树是具有如下特点的二
手撕红黑树——C++高阶数据结构详解
热门推荐
qq_61500888的博客
09-06 1万+
带你一命通关红黑树 十五分钟手撕数据结构原理
数据结构 - 红黑树
TPON的博客
11-12 766
红黑树的插入
有序表之红黑树
明朗晨光的专栏
02-21 587
红黑树的插入与删除调整
红黑树详解
lan墨的博客
07-28 900
红黑树 我们知道二叉查找树有较高的查找速度，同时为了避免单枝树等情况,又希望该二叉树接近于满二叉树，或者二叉树的每一个节点的左、右子树深度尽量相等，这样的二叉树称为平衡二叉树。平衡二叉树的常用实现方法有红黑树、AVL、替罪羊树、Treap、伸展树等。接下来我们看一下红黑树的原理。 定义 红黑树（英语：Red–black tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用...
图解红黑树
个人站点：javatv.net
07-26 839
写在前面 阅读本文你需具备知识点： 二叉树 平衡二叉树AVL 红黑树也是一棵二叉查找树，既然有了AVL树为什么还需要红黑树呢？ 之前在了平衡二叉树AVL实现中讲到了为什么使用平衡二叉树AVL（解决二叉查找树退化为类似链表的问题），最大的作用就是用于查找，其时间复杂度为O(logn)，但AVL树插入或删除节点后，若使得高度之差大于1，此时，AVL树的平衡状态就被破坏，需要旋转才能达到平衡。因此如果在插入和删除频繁的场景中就需要频繁的调整使之达到平衡，性能也随之下降。 因此，红黑树的提出是为了解决平衡树在插
红黑树
Anscor
04-13 835
红黑树是一种自平衡的二叉搜索树，与AVL树类似，在其上进行的插入、删除、查找操作的平均时间复杂度均为O(log&ThinSpace;n)O(log\,n)O(logn)。 但与AVL树不同的是，红黑树的平衡不是非常严格的平衡（即左右子树高度差不超过1），它牺牲了部分平衡性来换取了插入、删除时的少量旋转操作（最多3次）。 与普通二叉搜索树的区别 节点 颜色：相比于普通的二叉搜索树，红黑树...
数据结构进阶—红黑树
冯同学的博客
05-18 2584
了解什么是红黑树，红黑树的性质。 了解红黑树是如何进行插入数据的，以及插入数据时，遇到哪些情况只需要变色，哪些情况却需要旋转加变色
数据结构 | 【红黑树】图解原理
"You are worthy! You can do it!"
07-30 2692
红黑树的插入和删除。
二叉搜索树：红黑树的原理和实现
Pursue quality, not quantity.
03-30 1328
程序员的“浪漫”——手撕红黑树
手撕数据结构资源库及源码实现
“手撕数据结构”是计算机科学与软件工程领域中一个非常经典且重要的学习方法，广泛应用于算法训练、面试准备以及底层编程能力的提升。标题中的“hand-torn-data-structure-数据结构资源”明确指出了该资源的核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值