利用上班摸鱼时间，手撕红黑树（Java代码实现）

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

文章目录

操作术语

红黑树节点主要成员包括指向左孩子、右孩子、父节点的引用，一个boolean类型的变量标识是红或黑。
对于查询操作，跟二叉搜索树一样
插入、删除可能会影响红黑树的平衡，需要通过旋转和变色维护。

左旋逻辑：
设对节点p左旋，其目标为使节点p成为其右孩子节点的左孩子节点，操作为修改节点p和节点p的右孩子节点的父指针，再修改各自的孩子指针。

右旋逻辑：
设对节点p右旋，其目标为使节点p成为其左孩子节点的右孩子节点，操作为修改节点p和节点p的左孩子节点的父指针，再修改各自的孩子指针。

插入逻辑：

  1. 找插入位置，要插入的节点肯定为叶子节点，且设置为红色
  2. 判断其父节点颜色而做相应旋转以及变色操作

删除逻辑：

  1. 要删除的节点有左孩子节点和右孩子节点，找其直接后继节点，交换位置，待替换的节点指向后继节点的右孩子节点（如果存在的话，否则指向自己）
  2. 要删除的节点孩子节点仅有一个，替换节点即为其孩子节点
  3. 要删除的节点没有孩子节点，替换节点指向自己
  4. 如果替换节点不为删除节点，则将替换节点直接替换删除节点
  5. 根据删除节点颜色，做平衡操作
  6. 替换节点就是删除节点，修改指针引用，将其删除

图文并茂请参考https://blog.csdn.net/weixin_45685353/article/details/105912742?spm=1001.2014.3001.5502

代码实现

import java.util.*;

/**
 * 文件描述
 *
 * @author bipa
 * @date 2022/7/5
 */
public class RedBlackTree<T> {

    private TreeNode root;
    private Comparator<? super T> comparator;
    public RedBlackTree() {
    }

    public RedBlackTree(Comparator<? super T> comparator) {
        this.comparator = comparator;
    }

    class TreeNode {
        private T val;
        private TreeNode left;
        private TreeNode right;

        private TreeNode parent;
        private boolean red;

        public TreeNode(T val) {
            this.val = val;
        }
    }

    public TreeNode find(T target) {
        TreeNode p = root;
        for (; p != null; ) {
            int dir = comparator == null ? ((Comparable<? super T>) target).compareTo(p.val) : comparator.compare(target, p.val);
            if (dir < 0) {
                p = p.left;
            } else if (dir > 0) {
                p = p.right;
            } else {
                return p;
            }
        }
        return null;
    }

    public void insert(T val) {
        TreeNode p = root, pp = null;
        int dir = 0;
        for (; p != null; ) {
            pp = p;
            dir = comparator == null ? ((Comparable<? super T>) val).compareTo(p.val) : comparator.compare(val, p.val);
            if (dir < 0) {
                p = p.left;
            } else if (dir > 0) {
                p = p.right;
            } else {
                return;
            }
        }
        TreeNode node = new TreeNode(val);
        if (pp == null) {
            node.red = false;
            root = node;
            return;
        }
        if (dir < 0) {
            pp.left = node;
        } else {
            pp.right = node;
        }
        node.parent = pp;
        balanceInsert(node);
    }

    public List<T> getInnerValues() {
        List<T> list = new ArrayList<>();
        ArrayDeque<TreeNode> stack = new ArrayDeque<>();
        TreeNode p = root;
        while (p != null || !stack.isEmpty()) {
            while (p != null) {
                stack.addLast(p);
                p = p.left;
            }
            p = stack.removeLast();
            list.add(p.val);
            p = p.right;
        }
        return list;
    }

    public void remove(T target) {
        TreeNode t;
        if ((t = this.find(target)) == null) {
            return;
        }
        if (t == root && t.left == null && t.right == null) {
            root = null;
            return;
        }
        TreeNode tl = t.left, tr = t.right, replace;
        if (tl != null && tr != null) {
            TreeNode s = tr, sl;
            while ((sl = s.left) != null) {
                s = sl;
            }
            boolean c = t.red;
            t.red = s.red;
            s.red = c;
            TreeNode sr = s.right, tp = t.parent;
            if (tr == s) {
                t.parent = s;
                s.right = t;
            } else {
                TreeNode sp = s.parent;
                if ((t.parent = sp) != null) {
                    if (s == sp.left) {
                        sp.left = t;
                    } else {
                        sp.right = t;
                    }
                }
                s.right = tr;
                tr.parent = s;
            }
            t.left = null;
            if ((t.right = sr) != null) {
                sr.parent = t;
            }
            s.left = tl;
            tl.parent = s;
            if ((s.parent = tp) == null){
                root = s;
            } else if (t == tp.left) {
                tp.left = s;
            } else {
                tp.right = s;
            }
            if (sr != null) {
                replace = sr;
            } else {
                replace = t;
            }
        } else if (tl != null) {
            replace = tl;
        } else if (tr != null) {
            replace = tr;
        } else {
            replace = t;
        }
        if (replace != t) {
            TreeNode tp = replace.parent = t.parent;
            if (tp == null) {
                root = replace;
            } else if (tp.left == t) {
                tp.left = replace;
            } else {
                tp.right = replace;
            }
            t.left = t.right = t.parent = null;
        }
        if (!t.red) {
            balanceRemove(replace);
        }
        if (replace == t) {
            TreeNode tp = t.parent;
            t.parent = null;
            if (tp != null) {
                if (tp.left == t) {
                    tp.left = null;
                } else {
                    tp.right = null;
                }
            }
        }
    }

    private void balanceInsert(TreeNode t) {
        TreeNode tp, tpp, tppl, tppr;
        t.red = true;
        for (; ; ) {
            if ((tp = t.parent) == null) {
                t.red = false;
                return;
            }
            if (!tp.red || (tpp = tp.parent) == null) {
                return;
            }
            if ((tppl = tpp.left) == tp) {
                if ((tppr = tpp.right) != null && tppr.red) {
                    tppl.red = false;
                    tppr.red = false;
                    tpp.red = true;
                    t = tpp;
                } else {
                    if (t == tp.right) {
                        rotateLeft(t = tp);
                        tpp = (tp = t.parent) == null ? null : tp.parent;
                    }
                    if (tp != null) {
                        tp.red = false;
                        if (tpp != null) {
                            tpp.red = true;
                            rotateRight(tpp);
                        }
                    }
                }
            } else {
                if (tppl != null && tppl.red) {
                    tppl.red = false;
                    tp.red = false;
                    tpp.red = true;
                    t = tpp;
                } else {
                    if (t == tp.left) {
                        rotateRight(t = tp);
                        tpp = (tp = t.parent) == null ? null : tp.parent;
                    }
                    if (tp != null) {
                        tp.red = false;
                        if (tpp != null) {
                            tpp.red = true;
                            rotateLeft(tpp);
                        }
                    }
                }
            }
        }
    }

    private void balanceRemove(TreeNode t) {
        TreeNode tp, tpl, tpr;
        for (; ; ) {
            if (t == null || t == root) {
                return;
            } else if ((tp = t.parent) == null) {
                t.red = false;
                return;
            } else if (t.red) {
                t.red = false;
                return;
            } else if ((tpl = tp.left) == t) {
                if ((tpr = tp.right) != null && tpr.red) {
                    tpr.red = false;
                    tp.red = true;
                    rotateLeft(tp);
                    tpr = (tp = t.parent) == null ? null : tp.right;
                }
                if (tpr == null) {
                    t = tp;
                } else {
                    TreeNode sl = tpr.left, sr = tpr.right;
                    if ((sr == null || !sr.red) && (sl == null || !sl.red)) {
                        tpr.red = true;
                        t = tp;
                    } else {
                        if (sr == null || !sr.red) {
                            sl.red = false;
                            tpr.red = true;
                            rotateRight(tpr);
                            tpr = (tp = t.parent) == null ? null : tp.right;
                        }
                        if (tpr != null) {
                            tpr.red = tp != null && tp.red;
                            if ((sr = tpr.right) != null) {
                                sr.red = false;
                            }
                        }
                        if (tp != null) {
                            tp.red = false;
                            rotateLeft(tp);
                        }
                        t = root;
                    }
                }
            } else {
                if (tpl != null && tpl.red) {
                    tpl.red = false;
                    tp.red = true;
                    rotateRight(tp);
                    tpl = (tp = t.parent) == null ? null : tp.left;
                }
                if (tpl == null) {
                    t = tp;
                } else {
                    TreeNode sl = tpl.left, sr = tpl.right;
                    if ((sl == null || !sl.red) && (sr == null || !sr.red)) {
                        tpl.red = true;
                        t = tp;
                    } else {
                        if (sl == null || !sl.red) {
                            sr.red = false;
                            tpl.red = true;
                            rotateLeft(tpl);
                            tpl = (tp = t.parent) == null ? null : tp.left;
                        }
                        if (tpl != null) {
                            tpl.red = tp != null && tp.red;
                            if ((sl = tpl.left) != null) {
                                sl.red = false;
                            }
                        }
                        if (tp != null) {
                            tp.red = false;
                            rotateRight(tp);
                        }
                        t = root;
                    }
                }
            }
        }
    }

    private void rotateLeft(TreeNode t) {
        TreeNode tr, trl, tp;
        // 左旋，成为其右子节点的左子节点
        if (t != null && (tr = t.right) != null) {
            // 修改父指针
            if ((tp = tr.parent = t.parent) == null) {
                tr.red = false;
                root = tr;
            } else if (tp.left == t) {
                tp.left = tr;
            } else {
                tp.right = tr;
            }
            // 修改子指针
            if ((trl = t.right = tr.left) != null) {
                trl.parent = t;
            }
            // 成为其右子节点的左子节点
            tr.left = t;
            t.parent = tr;
        }
    }

    private void rotateRight(TreeNode t) {
        TreeNode tl, tlr, tp;
        // 右旋，成为其左子节点的右子节点
        if (t != null && (tl = t.left) != null) {
            // 修改父指针
            if ((tp = tl.parent = t.parent) == null) {
                tl.red = false;
                root = tl;
            } else if (tp.left == t) {
                tp.left = tl;
            } else {
                tp.right = tl;
            }
            // 修改子指针
            if ((tlr = t.left = tl.right) != null) {
                tlr.parent = t;
            }
            // 成为其左子节点的右子节点
            tl.right = t;
            t.parent = tl;
        }
    }
}

测试验证

测试类如下，


import com.bipa.tree.RedBlackTree;

import java.util.List;

/**
 * 文件描述
 *
 * @author bipa
 * @date 2022/7/5
 */
public class Main {

    public static final int LOOP_NUM = 10_000;

    public static void main(String[] args) {
        RedBlackTree<Integer> redBlackTree = new RedBlackTree<>();
        for (int i = LOOP_NUM; i > 0; i--) {
            redBlackTree.insert(i);
        }
        for (int i = LOOP_NUM; i > 0; i--) {
            // 获取红黑树中序遍历后的节点值
            List<Integer> list = redBlackTree.getInnerValues();
            System.out.println(list);

            // 验证是否升序
            for (int j = 1; j < list.size(); j++) {
                if (list.get(j-1) > list.get(j)) {
                    // 发现降序，打印fail，结束方法
                    System.out.println("fail!");
                    return;
                }
            }
            redBlackTree.remove(i);
        }
        System.out.println("succ");
    }

}

运行结果截图，
在这里插入图片描述

b17a
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
用Python写了10个小游戏，上班能摸鱼几天？
ch950401的博客
05-05 722
【代码】用Python写了10个小游戏，上班能摸鱼几天？
手撕红黑树（Red-Black Tree）
林慢慢的博客
07-06 2755
红黑树 （C++实现）
手撕红黑树-java版
YY3710YY的博客
08-04 305
手撕红黑树-java版 红黑树的五个平衡条件 每个节点非黑即红 根节点是黑色 叶节点（即虚拟叶节点，红黑树中的叶节点指的是看不见的虚拟空节点）是黑色 如果一个节点是红色，则它的两个子节点都是黑色的 从根节点出发到所有叶节点路径上，黑色节点数量相同 红黑树最长路径是最短路径的2倍 相比于AVL树，红黑树的控制条件更加松散，为了降低在插入和删除节点后的调整次数 红黑树自平衡的三种依据 变色：节点的颜色由黑变红或者由红变黑 左旋：已某一节点作为支点（旋转节点），其右子节点变为旋转节点的父节点，右子节点的左节
【数据结构与算法】—— 手撕红黑树
m0_56069910的博客
08-23 293
手撕红黑树
用python实现自动化办公------上班摸鱼
weixin_52134263的博客
07-09 7142
用python实现自动化办公------上班摸鱼 好多公司领导会在员工电脑上安装监控软件，员工是否在工作都在领导的监控之下。对于很多人来说，摸鱼成为了一件奢侈的事情，但是对于程序员来说，尤其是学过自动化办公的程序员来说，这简直就是一个小case，只要我想摸，就没有摸不到的鱼。我有一万种摸鱼方式，你选择哪一种？ 如果工作已然完成，没有其它任务，但是又不想让老板看到自己很闲，那么开发一个小摸鱼程序显得多么合情合理。以下就是我开发的一个简单的摸鱼程序，你只需要尝着咖啡，或者打着游戏就能避开老板的火眼金睛。 摸鱼功
手撕代码_C语言手撕_C++_手撕代码c++_
10-01
本资源“手撕代码_C语言手撕_C++_手撕代码c++_”聚焦于C语言和C++的面试题，特别关注如何使用两个队列来实现堆栈的功能。这个话题对于理解和掌握数据结构以及算法有着重要意义，因为堆栈和队列是基础数据结构，而C++...
EventBus最佳实践：Java手撕实现ESB底层事件委托处理机制的思路，配套演示代码
01-05
本代码实现了一个简单的EventBus结构。 当一个组织中的人数众多，我们需要将关注点拆分，以避免陷入逻辑混乱和不必要的代码冲突，而且能带来一些可以让组件复用的好处。 但是如果将一个复杂的问题解耦成若干个小问题...
Java实现算法BogoSort
12-25
Java实现算法BogoSort
Java实现算法BitonicSort
12-25
Java实现算法BitonicSort
列举Java面试中手撕代码的各种题型.zip
最新发布
01-01
【一线互联网大厂Java核心面试题库】Java基础、异常、集合、并发编程、JVM、Spring全家桶、MyBatis、Redis、数据库、中间件MQ、Dubbo、Linux、Tomcat、ZooKeeper、Netty等等..
所有叶子都是黑色(nil节点)_看了这么多篇红黑树文章，你都理解了嘛？
weixin_30899023的博客
01-18 3393
很早之前就想写一篇关于红黑树的文章，但是由于担心自己理解的不透彻，就一直不敢下笔。于是在重新看了很多篇文章和资料之后，决定彻彻底底的把红黑树搞清楚。也希望让你在面试中游刃有余。OK，废话不多说，开始今天的文章。整篇文章的思路是这样的，红黑树其实就是一种数据结构，设计它的目的就是为了高效地进行增删改查，所以我们文章的顺序也会按照这个思路来进行。我们先从二叉查找树逐渐引入到红黑树，然后再详细的讲解。你...
红黑树插入删除算法——java代码实现
Jodanluo的博客
02-09 245
插入删除算法思想见上一篇文章：https://blog.csdn.net/Jodanluo/article/details/104180400 一、节点类 enum Color {RED , BLACK}; public class RBNode { public int value; public Color color; public RBNode left; ...
对红黑树的插入、删除理解及java代码实现
a258216248的博客
08-23 518
红黑树的性质： 节点要么是黑色，要么是红色； 根节点永远是黑色； 红色节点的子节点只能是黑色； 从一个节点到一个null引用的每一条路径必须包含相同数目的黑色节点； 根据红黑树的性质：如果节点的两个子节点都为红色，则可以进行颜色反转，节点变红，两个子节点都变黑； 节点的旋转：如果需要插入的节点相对于父亲节点的位置 和 父亲节点相对于 爷爷节点的位置相同时，单旋转，如果位置不同，则需要...
红黑树删除java实现
m0_37867129的博客
11-05 445
package Algorithms; import java.security.Key; public class RedAndBlackDelete&lt;Key extends Comparable&lt;Key&gt;,Value&gt; {     public static void main(String[] args) {         // TODO Auto-gener...
红黑树理解以及Java实现
热门推荐
qq_41854763的博客
09-13 1万+
我对红黑树的理解 红黑树本身并不复杂，只是在插入删除的时候情况比较多，如果强行记忆的话会显得比较困难，而且容易忘记。所以以前对红黑树一直没有很好的掌握。恰好这次借着复习数据结构的机会，静下心来仔细的学习了一下红黑树，所以用这篇文章把我对红黑树的操作的理解记录下来，在理解的基础上记忆会容易得多，这样以后就不用重复学习啦！ 1. 红黑树的定义 红黑树是一颗二叉查找树，且具有如下...
【Java】红黑树的删除操作
qq_44772323的博客
07-15 579
删除修复操作的四种情况： 1.待删除的节点的兄弟节点是红色节点 2.待删除的节点的兄弟节点是黑色的节点，且兄弟节点的子节点都是黑色的 3.待调整的兄弟节点是黑色的节点，且兄弟节点的左子树是红色的，右节点是黑色的（兄弟节点在右边），如果兄弟节点在左边的话，就是兄弟节点的右子节点是红色的，左节点是黑色的。 4.待调整的节点的兄弟节点是黑色的节点，且右子节点是红色的（兄弟节点在右边），如果兄弟节点...
红黑树（中）完整建树过程
Joker_ZJN的博客
07-28 1248
手撕JAVA（十四）一文中有些地方表述有误，笔者日后在做修改。这里用画图的方式展示两次红黑树的完整建图过程，一次简单，一次复杂，根据建图过程，就可以理解红黑树是如何实现的。 总结的几点为： 1.根节点必为黑色，任何调整动作都无法将根节点染红 2.新插入节点的父节点和uncle节点同为红色，直接染黑父节点和uncle节点，染红祖父节点（如果祖父节点为根节点，就免疫） 3.新插入父节点为红色，...
手撕红黑树Java_【算法】手撕红黑树（上）—— 基本性质以及插入实现（附带代码实现）...
weixin_35934037的博客
02-28 160
1 /**2 * 手撕红黑树3 * By 469の瘸子 (意义不明的口胡：现在应该是420の的瘸子233)4 * **/5 public class RedBlackTree & PrintToDOS>{67 public static final boolean black = true;8 public static final boole...
手撕红黑树
qq_33688997的博客
11-18 1914
#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
来个上班摸鱼python游戏
03-26
好的，这里是一个简单的 Python 游戏，允许用户在上班摸鱼时玩耍。 ```python import random print("欢迎来到上班摸鱼游戏！") print("你的任务是躲避上司并尽可能长时间的摸鱼。") time_left = 60 fish_caught = 0 boss_position = random.randint(0,10) player_position = 5 while time_left > 0: print("时间还剩下", time_left, "秒") print("你的位置：", ">"*player_position, "🎣", "<"*(10-player_position)) print("老板的位置：", ">"*boss_position, "🧑", "<"*(10-boss_position)) user_input = input("向左 (l) 或向右 (r) 移动：") if user_input == "l": player_position -= 1 elif user_input == "r": player_position += 1 else: print("无效输入。请重新输入。") continue if player_position == boss_position: print("你被老板抓住了！") break fish_caught += 1 time_left -= 1 print("游戏结束！你摸到了", fish_caught, "条鱼。") ``` 上面的代码会生成一个 10 X 1 的游戏场景，包括一个渔人、一条鱼和一个老板。玩家可以通过输入 "l" 或 "r" 来控制渔人的位置，以避免被老板发现。每当玩家摸到一条鱼时，游戏时间就会减少一秒，一旦时间用完或玩家被老板抓住，游戏就会结束。最后，输出玩家所获得的鱼的数量。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

b17a

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

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

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

打赏作者

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

抵扣说明：

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

余额充值