红黑树的插入删除

已于 2022-09-06 14:41:18 修改
阅读量305 收藏
点赞数
分类专栏： JAVA 文章标签： java
于 2022-09-06 09:25:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53593478/article/details/126718023
版权
这段代码详细展示了红黑树中插入和删除节点后的平衡调整操作。插入节点时，根据节点颜色和父节点位置进行不同旋转和变色操作。删除节点时，处理二节点、三节点和四节点的情况，通过旋转和变色保持红黑树性质。整个过程涉及前驱节点、后继节点的寻找以及节点颜色和旋转的管理。
摘要由CSDN通过智能技术生成

插入：

向二节点插：直接插入

向三节点插：三个节点构成三角，直接插

                      三个节点构成直线，变色旋转一次

                      三个节点构成折线，变色一次，旋转两次

向四节点插：父辈节点变黑，爷爷节点变红

 

/**
     * 对插入的节点进行调整
     * @param node
     */
    private void fixAfterPut(Node<K,V> node) {
        //node的父节点是爷爷的左孩子
        while (node.parent != null && node.parent.color == RED) {
            if(parentOf(node) == leftOf(parentOf(parentOf(node)))) {
                Node uncle = parentOf(parentOf(node)).right;
                if(colorOf(uncle) == RED) {
                    setColor(parentOf(node), BLACK);
                    setColor(uncle, BLACK);
                    node = parentOf(parentOf(node));
                    if(node != root) {
                        setColor(node, RED);
                    }
                } else {
                    if(rightOf(parentOf(node)) == node) {
                        node = parentOf(node);
                        leftRotate(node);
                    }
                    setColor(parentOf(node), BLACK);
                    setColor(parentOf(parentOf(node)), RED);
                    rightRotate(parentOf(parentOf(node)));
                }
            } else {
                //node的父节点是爷爷的右孩子
                Node uncle = parentOf(parentOf(node)).left;
                if(colorOf(uncle) == RED) {
                    setColor(parentOf(node), BLACK);
                    setColor(uncle, BLACK);
                    node = parentOf(parentOf(node));
                    if(node != root) {
                        setColor(node, RED);
                    }

                } else {
                    if(leftOf(parentOf(node)) == node) {
                        node = parentOf(node);
                        rightRotate(node);
                    }
                    setColor(parentOf(node), BLACK);
                    setColor(parentOf(parentOf(node)), RED);
                    leftRotate(parentOf(parentOf(node)));
                }
            }
        }
    }

删除：若被删除节点有两个子节点，找其前驱或后继节点替代

若删除的节点对应234树是三节点或四节点删除，红色直接删除，黑色则找其子节点代替变黑

若删除的节点对应234树是二节点删除，需要调整，找到真正的兄弟节点，向兄弟节点借节点平衡黑色

        若兄弟有1个子节点，该子节点与兄弟与父节点构成直线，直接变色旋转，若构成折线，需变色旋转两次。若兄弟有2个子节点，直接变色旋转。

 

        若兄弟无子节点，兄弟变红，若父亲为红色，父亲变黑维持平衡结束，否则父亲向其兄弟借，借到平衡结束，否则父亲兄弟变黑，重复此过程

二节点删除调整代码：

private void fixAfterRemove(Node node) {
        while (colorOf(node) != RED && node != root) {
            //node为左孩子
            if (node == leftOf(node.parent)) {
                Node brother = rightOf(node.parent);
                if (colorOf(brother) == RED) {
                    setColor(brother, BLACK);
                    setColor(parentOf(node), RED);
                    leftRotate(parentOf(node));
                    brother = rightOf(parentOf(node));
                }
                //兄弟节点有孩子节点
                if (colorOf(leftOf(brother)) == BLACK && colorOf(rightOf(brother)) == BLACK) {
                    setColor(brother, RED);
                    node = node.parent;
                } else {
                    if (leftOf(brother) != null && rightOf(brother) == null) {
                        setColor(brother, RED);
                        setColor(brother.left, BLACK);
                        rightRotate(brother);
                        brother = rightOf(parentOf(node));
                    }
                    setColor(brother, colorOf(parentOf(node)));
                    setColor(rightOf(brother), BLACK);
                    setColor(parentOf(node), BLACK);
                    leftRotate(parentOf(node));
                    node = root;
                }

            } else {
                Node brother = leftOf(node.parent);
                if (colorOf(brother) == RED) {
                    setColor(brother, BLACK);
                    setColor(parentOf(node), RED);
                    rightRotate(parentOf(node));
                    brother = leftOf(parentOf(node));
                }
                //兄弟节点有孩子节点
                if (colorOf(leftOf(brother)) == BLACK && colorOf(rightOf(brother)) == BLACK) {
                    setColor(brother, RED);
                    node = node.parent;
                } else {
                    if (rightOf(brother) != null && leftOf(brother) == null) {
                        setColor(brother, RED);
                        setColor(rightOf(brother), BLACK);
                        leftRotate(brother);
                        brother = leftOf(parentOf(node));
                    }
                    setColor(brother, colorOf(parentOf(node)));
                    setColor(leftOf(brother), BLACK);
                    setColor(parentOf(node), BLACK);
                    rightRotate(parentOf(node));
                    node = root;
                }
            }
        }
        setColor(node, BLACK);

    }

全部代码：

package tree;

import java.util.ArrayList;
import java.util.List;

public class RBTree<K extends Comparable<K>, V> {

    private static final boolean RED = false;
    private static final boolean BLACK = true;
    private Node<K, V> root;

    public boolean contains(K key) {
        return find(key) != null;
    }
    private Node find(K key) {
        if (key == null) return null;
        Node node = root;
        while (node != null) {
            int compare = key.compareTo((K)node.key);
            if(compare == 0) return node;
            else if(compare > 0) node = node.right;
            else node = node.left;
        }
        return null;
    }
    public V remove(K key) {
        Node node = getNode(key);
        if(node == null) return null;
        V oldValue = (V)node.value;
        delete(node);

        return oldValue;
    }

    private void delete(Node node) {
        if(node == null) return;
        //node有两个孩子节点， 找其后继节点替换，并删除后继节点
        if(node.left != null && node.right != null) {
//            Node sucessor = sucessor(node);
            Node sucessor = predecessor(node);
            node.key = sucessor.key;
            node.value = sucessor.value;
            node = sucessor;
        }
        Node replace = node.left == null? node.right : node.left;
        //node没有孩子节点，直接删除
        if (replace == null) {
            if (node == root) {
                root = null;
                return;
            }
            if (node.color == BLACK) {
                //要删除黑色叶子节点，需要调整
                fixAfterRemove(node);
            }
            if (node.parent.left == node) node.parent.left = null;
            else if (node.parent.right == node) node.parent.right = null;
            node.parent = null;
        } else {
            //node有一个孩子节点，将孩子节点和父节点连接
            replace.parent = node.parent;
            if (node == root) {
                root = replace;
            } else if (node.parent.left == node) {
                node.parent.left = replace;
            } else if (node.parent.right == node) {
                node.parent.right = replace;
            }
            node.right = node.left = node.parent = null;
            if (node.color == BLACK) {
                //相当于2-3-4树三节点的删除，replace一定是红色，直接染黑
                replace.color = BLACK;
            }
        }
    }

    private void fixAfterRemove(Node node) {
        while (colorOf(node) != RED && node != root) {
            //node为左孩子
            if (node == leftOf(node.parent)) {
                Node brother = rightOf(node.parent);
                if (colorOf(brother) == RED) {
                    setColor(brother, BLACK);
                    setColor(parentOf(node), RED);
                    leftRotate(parentOf(node));
                    brother = rightOf(parentOf(node));
                }
                //兄弟节点有孩子节点
                if (colorOf(leftOf(brother)) == BLACK && colorOf(rightOf(brother)) == BLACK) {
                    setColor(brother, RED);
                    node = node.parent;
                } else {
                    if (leftOf(brother) != null && rightOf(brother) == null) {
                        setColor(brother, RED);
                        setColor(brother.left, BLACK);
                        rightRotate(brother);
                        brother = rightOf(parentOf(node));
                    }
                    setColor(brother, colorOf(parentOf(node)));
                    setColor(rightOf(brother), BLACK);
                    setColor(parentOf(node), BLACK);
                    leftRotate(parentOf(node));
                    node = root;
                }

            } else {
                Node brother = leftOf(node.parent);
                if (colorOf(brother) == RED) {
                    setColor(brother, BLACK);
                    setColor(parentOf(node), RED);
                    rightRotate(parentOf(node));
                    brother = leftOf(parentOf(node));
                }
                //兄弟节点有孩子节点
                if (colorOf(leftOf(brother)) == BLACK && colorOf(rightOf(brother)) == BLACK) {
                    setColor(brother, RED);
                    node = node.parent;
                } else {
                    if (rightOf(brother) != null && leftOf(brother) == null) {
                        setColor(brother, RED);
                        setColor(rightOf(brother), BLACK);
                        leftRotate(brother);
                        brother = leftOf(parentOf(node));
                    }
                    setColor(brother, colorOf(parentOf(node)));
                    setColor(leftOf(brother), BLACK);
                    setColor(parentOf(node), BLACK);
                    rightRotate(parentOf(node));
                    node = root;
                }
            }
        }
        setColor(node, BLACK);

    }

    private Node getNode(K key) {
        if (key == null) return null;
        Node<K, V> node = root;
        while (node != null) {
            int compare = key.compareTo(node.key);
            if(compare == 0) return node;
            else if (compare > 0) {
                node = node.right;
            } else {
                node = node.left;
            }
        }
        return null;
    }

    /**
     * 查找前驱节点
     * @param node
     * @return
     */
    private Node predecessor(Node node) {
        if(node == null || node.left == null) return null;
        node = node.left;
        Node pre = node;
        while (node != null) {
            pre = node;
            node = node.right;
        }
        return pre;
    }

    /**
     * 查找后继节点
     * @param node
     * @return
     */
    private Node sucessor(Node node) {
        if(node == null || node.right == null) return null;
        node = node.right;
        Node pre = node;
        while (node != null) {
            pre = node;
            node = node.left;
        }
        return pre;
    }
    public Node getRoot() {
        return root;
    }
    /**
     * 按升序返回搜索二叉树的值
     * @return
     */
    public List<Entry<K, V>> list() {
        List<Entry<K, V>> list = new ArrayList<>();
        ldr(root, list);
        return list;
    }

    private void ldr(Node<K, V> node, List<Entry<K, V>> list) {
        if (node == null) return;
        ldr(node.left, list);
        list.add(new Entry<K, V>(node.key, node.value));
        ldr(node.right, list);
    }
    public void put(K key, V value) {
        if(root == null) {
            root = new Node<K, V>(null, null, null, BLACK, key, value);
            return;
        }
        Node node = root;
        Node p = null;
        int compare = 0;
        while (node != null) {
           compare = node.key.compareTo(key);
            p = node;
            if(compare > 0) {
                node = node.left;
            } else if(compare < 0) {
                node = node.right;
            } else {
                node.setValue(value);
                return;
            }
        }
        Node<K, V> insertNode = new Node(p, null, null, RED, key, value);
        if (compare > 0) {
            p.left = insertNode;
        } else {
             p.right = insertNode;
        }
        //调整
        fixAfterPut(insertNode);


    }

    /**
     * 对插入的节点进行调整
     * @param node
     */
    private void fixAfterPut(Node<K,V> node) {
        //node的父节点是爷爷的左孩子
        while (node.parent != null && node.parent.color == RED) {
            if(parentOf(node) == leftOf(parentOf(parentOf(node)))) {
                Node uncle = parentOf(parentOf(node)).right;
                if(colorOf(uncle) == RED) {
                    setColor(parentOf(node), BLACK);
                    setColor(uncle, BLACK);
                    node = parentOf(parentOf(node));
                    if(node != root) {
                        setColor(node, RED);
                    }
                } else {
                    if(rightOf(parentOf(node)) == node) {
                        node = parentOf(node);
                        leftRotate(node);
                    }
                    setColor(parentOf(node), BLACK);
                    setColor(parentOf(parentOf(node)), RED);
                    rightRotate(parentOf(parentOf(node)));
                }
            } else {
                //node的父节点是爷爷的右孩子
                Node uncle = parentOf(parentOf(node)).left;
                if(colorOf(uncle) == RED) {
                    setColor(parentOf(node), BLACK);
                    setColor(uncle, BLACK);
                    node = parentOf(parentOf(node));
                    if(node != root) {
                        setColor(node, RED);
                    }

                } else {
                    if(leftOf(parentOf(node)) == node) {
                        node = parentOf(node);
                        rightRotate(node);
                    }
                    setColor(parentOf(node), BLACK);
                    setColor(parentOf(parentOf(node)), RED);
                    leftRotate(parentOf(parentOf(node)));
                }
            }
        }

    }

    private void setColor(Node node, boolean color) {
        if (node != null) {
            node.color = color;
        }
    }
    private boolean colorOf(Node node) {
        return node == null? BLACK : node.color;
    }

    private Node parentOf(Node node) {
        return node == null? null : node.parent;
    }

    private Node leftOf(Node node) {
        return node == null? null : node.left;
    }

    private Node rightOf(Node node) {
        return  node == null? null : node.right;
    }

    /**
     * 左旋
     * @param node
     */
    private void leftRotate(Node node) {
        if (node != null && node.right != null) {
            Node r = node.right;
            node.right = r.left;
            if(r.left != null) {
                r.left.parent = node;
            }
            r.left = node;
            Node parent = node.parent;
            r.parent = parent;
            node.parent = r;
            if(parent == null) {
                root = r;
            } else if(parent.left == node) {
                parent.left = r;
            } else {
                parent.right = r;
            }
        }
    }

    /**
     * 右旋
     * @param node
     */
    private void rightRotate(Node node) {
        if (node != null && node.left != null) {
            Node l = node.left;
            node.left = l.right;
            if(l.right != null) {
                l.right.parent = node;
            }
            Node parent = node.parent;
            l.right = node;
            node.parent = l;
            l.parent = parent;
            if(parent == null) {
                root = l;
            } else if(parent.left == node) {
                parent.left = l;
            } else {
                parent.right = l;
            }
        }
    }
    static class Entry<K, V> {
        private K key;
        private V value;

        public Entry() {
        }

        public Entry(K key, V value) {
            this.key = key;
            this.value = value;
        }

        public K getKey() {
            return key;
        }

        public void setKey(K key) {
            this.key = key;
        }

        public V getValue() {
            return value;
        }

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

        @Override
        public String toString() {
            return "Entry{" +
                    "key=" + key +
                    ", value=" + value +
                    '}';
        }
    }
    static class Node<K extends Comparable<K>, V> {
        private Node parent;
        private Node left;
        private Node right;
        private boolean color;
        private K key;
        private V value;

        public Node getParent() {
            return parent;
        }

        public void setParent(Node parent) {
            this.parent = parent;
        }

        public Node getLeft() {
            return left;
        }

        public void setLeft(Node left) {
            this.left = left;
        }

        public Node getRight() {
            return right;
        }

        public void setRight(Node right) {
            this.right = right;
        }

        public boolean isColor() {
            return color;
        }

        public void setColor(boolean color) {
            this.color = color;
        }

        public K getKey() {
            return key;
        }

        public void setKey(K key) {
            this.key = key;
        }

        public V getValue() {
            return value;
        }

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

        public Node(Node parent, Node left, Node right, boolean color, K key, V value) {
            this.parent = parent;
            this.left = left;
            this.right = right;
            this.color = color;
            this.key = key;
            this.value = value;
        }
    }
}

-用户昵称已存在-
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JVM 基础知识
纯小白私人博客
07-18 235
JVM 基础知识、面试
红黑树的插入与删除
朱广健的博客
05-26 9669
红黑树（Red Black Tree） 是一种自平衡二叉查找树。红黑树和AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。红黑树可以在O(log n)时间内完成查找，插入和删除操作。 二叉搜索树可以看 二叉搜索树 AVL树可以看 AVL树的插入与删除 1. 红黑树的性质 红黑树的自平衡依赖于它的以下性质： 性质1. 结点是红
2021-06-15
qq_23565961的博客
06-15 111
Day01 标题 三级标题 四级标题 五级标题 六级标题 字体 helloworld helloworld helloworld 引用 分割线 — *** 图片 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NYVwST1Z-1623749640304)(/home/zhurong/图片/Camera/高雄.jpg)] 超链接 点击跳转 列表 A B C A B C 表格 名字 性别 生日 张三 男 1997
Python 列表（list）
qq_43229278的博客
10-11 358
列表（list）是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。列表可以进行的操作包括索引，切片，加，乘，检查成员。 此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。 列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。（列表的数据项不需要具有相同的类型）示例： l = ["张三","李四","王五",123,555] 获取列表元素： print(l[0]) #输
【C++】红黑树插入删除
fight_p的博客
12-14 1340
这是一篇关于红黑树插入删除为主要内容的文章，本文详细讲述了红黑树的插入情形以及如何解决，代码如何实现，当然最重要的就是红黑树的删除，虽然红黑树删除不简单，但是删除的无非就是叶子节点，一个孩子的节点，两个孩子的节点，被删节点是红色还是黑色。其中最重要的就是删除的黑色叶子节点这有些麻烦，其他的都很简单！本文把每个情况都详细罗列出来。其实看完之后红黑树的删除真的没有那么难！！！
红黑树的插入和删除
Djsnxbjans的博客
06-10 1544
红黑树简述 红黑树的概念 红黑树的性质 红黑树结点定义 一，红黑树的插入 插入调整 插入代码 二，红黑树的验证 三，红黑树的删除 待删除的结点只有一个子树 删除结点颜色为红色 删除结点颜色为黑色 删除的结点为叶子节点 删除结点颜色为红色 删除结点颜色为黑色 红黑树删除代码 四，红黑树与AVL树的比较
红黑树插入和删除的各种情况分析
jianjian的博客
01-11 2069
1.红黑树的定义 红黑树是一种自平衡的二叉查找树，是一种高效的查找树。 一颗m阶的B树，或为空树，或者满足依稀阿特性的M叉树； 每个节点是红色或黑色 根是黑色 所有叶子都是黑色（叶子是NIL节点） 如果一个节点是红色的，则他的两个儿子是黑色的（从每个叶子到根的所有路径上不能有两个连续的红色节点） 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点（简称黑高） 2.B树的数据结构 typedef int KEY_TYPE; //定义红黑树的节点 typedef struct _rbtree_n
红黑树的插入和删除详解
xfy_von的博客
08-10 1614
红黑树RB-tree 找了很多其他人的，红黑树的插入大部分都能理解，在删除部分有些博客很难理解进行，就自己写了一篇详细的，有问题欢迎请指出。 作为一种广泛应用的平衡二叉搜索树之一，需要我们有些清晰的了解 红黑树的结点增删改查效率非常优良，都为log(N)，其应用十分广泛： Linux内核进程调度由红黑树管理进程控制块。 Epoll用红黑树管理事件块。 C++ STL中的map和set的底层实现。 用于理解红黑树的生成演示网站：https://www.cs.usfca.edu/~galles/visual
红黑树插入删除详细步骤动画演示、与AVL树的区别
Xx__WangQi的博客
05-09 710
目录 红黑树认识 红黑树插入 红黑树删除 红黑树和AVL树（平衡二叉树）的定义、特点以及两者的区别 定义 性质 区别 红黑树动画在线演示 红黑树认识 红黑树是一种二叉排序树，先来看一下二叉排序树的基本性质： 若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值； 它的左、右子树也分别为二叉排序树 红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加
红黑树的插入
Colorful_X的博客
06-17 1075
文章目录红黑树定义红黑树性质红黑树的插入 红黑树定义         红黑树(Red Black Tree) 是一种自平衡的二叉查找树，典型用途是实现关联数组，红黑树与AVL树类似，都是在插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。         红黑树查找、插入删除的时间复杂度为O（logn）  &nbsp
红黑树插入删除算法
09-27
红黑树插入删除算法，算法导论上算法，可以运行
红黑树插入删除伪算法
03-10
在"红黑树插入删除伪算法（含图示）"文件中，你将能看到具体的操作流程和变化过程，这对于理解红黑树的内部工作机制非常有帮助。 总的来说，红黑树是一种高效的数据结构，广泛应用于数据库系统、编译器、虚拟机等...
红黑树插入删除的平衡操作
03-17
红黑树插入，删除时各种状态的平衡操作。
红黑树插入与删除
10-11
主要讲述红黑树的插入、查找、删除、并设计了测试程序去测试程序的正确性
红黑树插入与删除.xmind
03-26
红黑树的插入与删除各种情况，内容更正了之前版本的错误
JAVA进阶补充
2301_80150315的博客
08-15 1014
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
手撕快排——三种实现方法（附动图及源码）
jsjs1346的博客
08-16 899
🤖💻👨‍💻👩‍💻🌟🚀🤖🌟👨‍💻👩‍💻👨‍💻👩‍💻🚀是一种高效的排序算法，广泛应用于各种场景。它采用策略，将一个数组分成两个子数组，然后递归地对这两个子数组进行排序。本文将介绍三种快速排序的实现方法，并附上相应的源码。⚙️一、快速排序的基本原理一个基准元素（pivot）分成两个子数组递归合并O(n log n)O(n log n)O(n^2)后文我们将给出优化方案O(log n)📚三、实现霍尔方法是快速排序原始版本中使用的分区方法。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1136
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
【Spring框架】
最新发布
m0_71941456的博客
08-18 836
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
红黑树插入删除详解：规则与操作推导
在这个详细的整理文档中，我们将探讨红黑树插入和删除操作的关键步骤以及旋转原则。 1. 插入操作: - 插入过程与普通二叉搜索树相同，首先将新节点标记为红色。 - 从新插入的节点开始，向上调整颜色，确保满足红黑...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值