红黑树的null节点

红黑树是一种自平衡二叉查找树，它的设计是为了保证在各种操作（如插入、删除和查找）后的最坏情况下的性能。在红黑树中，每个节点都有一个颜色属性，可以是红色或黑色。为了支持空节点，红黑树会定义一个特殊的"NULL"节点。

1. **NULL节点**：在红黑树中，每个非叶子节点（即非终端节点，既不是根也不是叶子）都会有一个子节点表示为NULL。这是用来表示某个方向上没有子节点的情况，例如左孩子或右孩子可能为空。NULL节点并不是实际的数据存储位置，而是一个标记，表示该位置不存在元素。

2. **空树的表示**：对于根节点，如果它是NULL，则表示整棵树为空；如果它被标记为红色或黑色，则表示树仅包含根节点，且为空。

3. **插入和删除操作**：当执行插入或删除操作时，红黑树会保持其规则不变，如每条路径从根到叶子的最长颜色序列不超过两倍最短，这样即使添加或移除节点也不会导致严重的不平衡。在处理NULL节点时，这些规则同样适用。

相关问题

hashmap 红黑树

HashMap中的红黑树是一种平衡二叉树，它用于解决在链表长度过长时的性能问题。在JDK 1.8之后，HashMap的实现通过链表和红黑树来解决哈希冲突的问题。当链表中的节点数超过8个时，链表将会转化为红黑树，从而提高了查询、修改和删除操作的效率。红黑树中的每个节点包含指向父节点、左孩子、右孩子和前驱节点的指针，还有一个表示节点颜色的属性。红黑树的时间复杂度为O(log n)，能够更有效地处理大量数据的存储和访问。<span class="em">1</span><span class="em">2</span><span class="em">3</span>
#### 引用[.reference_title]
- *1* [Java8 HashMap源码的简单分析（1）](https://download.csdn.net/download/weixin_38632763/13753415)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"]
- *2* *3* [HashMap之红黑树详解](https://blog.csdn.net/X6954636/article/details/119705176)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"]
[ .reference_list ]

java 红黑树实现

Java中的红黑树实现主要是通过对节点进行变色和旋转来维持其特性。具体实现可以参考以下步骤：

1.定义红黑树节点类，包括节点值、颜色、左右子节点等属性。

2.定义红黑树类，包括根节点、插入节点、删除节点等方法。

3.在插入节点时，根据其父节点和父节点的兄弟节点进行变色和旋转，以维持红黑树的特性。

4.在删除节点时，同样需要进行变色和旋转，以保证删除后的树仍然是一颗红黑树。

以下是一个简单的Java红黑树实现示例：

public class RBNode<T extends Comparable<T>> {
    boolean color;//颜色
    T key;//关键字(键值)
    RBNode<T> left;//左子节点
    RBNode<T> right;//右子节点
    RBNode<T> parent;//父节点

    public RBNode(boolean color, T key, RBNode<T> parent, RBNode<T> left, RBNode<T> right) {
        this.color = color;
        this.key = key;
        this.parent = parent;
        this.left = left;
        this.right = right;
    }
}

public class RBTree<T extends Comparable<T>> {
    private RBNode<T> root;//根节点

    //插入节点
    public void insert(T key) {
        RBNode<T> node = new RBNode<T>(false, key, null, null, null);
        if (node != null) {
            insert(node);
        }
    }

    //插入节点
    private void insert(RBNode<T> node) {
        RBNode<T> current = null;//当前节点
        RBNode<T> x = this.root;//从根节点开始查找
        //查找插入位置
        while (x != null) {
            current = x;
            if (node.key.compareTo(x.key) < 0) {
                x = x.left;
            } else {
                x = x.right;
            }
        }
        node.parent = current;
        if (current != null) {
            if (node.key.compareTo(current.key) < 0) {
                current.left = node;
            } else {
                current.right = node;
            }
        } else {
            this.root = node;
        }
        //修正红黑树
        insertFixUp(node);
    }

    //修正红黑树
    private void insertFixUp(RBNode<T> node) {
        RBNode<T> parent, gparent;//父节点和祖父节点
        //需要修正的条件：父节点存在，且父节点的颜色是红色
        while (((parent = parentOf(node)) != null) && isRed(parent)) {
            gparent = parentOf(parent);//祖父节点
            //父节点是祖父节点的左子节点
            if (parent == gparent.left) {
                RBNode<T> uncle = gparent.right;//叔叔节点
                //case1:叔叔节点也是红色
                if ((uncle != null) && isRed(uncle)) {
                    setBlack(parent);
                    setBlack(uncle);
                    setRed(gparent);
                    node = gparent;
                    continue;
                }
                //case2:叔叔节点是黑色，且当前节点是右子节点
                if (node == parent.right) {
                    RBNode<T> tmp;
                    leftRotate(parent);
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }
                //case3:叔叔节点是黑色，且当前节点是左子节点
                setBlack(parent);
                setRed(gparent);
                rightRotate(gparent);
            } else {//父节点是祖父节点的右子节点
                RBNode<T> uncle = gparent.left;//叔叔节点
                //case1:叔叔节点也是红色
                if ((uncle != null) && isRed(uncle)) {
                    setBlack(parent);
                    setBlack(uncle);
                    setRed(gparent);
                    node = gparent;
                    continue;
                }
                //case2:叔叔节点是黑色，且当前节点是左子节点
                if (node == parent.left) {
                    RBNode<T> tmp;
                    rightRotate(parent);
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }
                //case3:叔叔节点是黑色，且当前节点是右子节点
                setBlack(parent);
                setRed(gparent);
                leftRotate(gparent);
            }
        }
        setBlack(this.root);//将根节点设为黑色
    }

    //左旋
    private void leftRotate(RBNode<T> x) {
        RBNode<T> y = x.right;
        x.right = y.left;
        if (y.left != null) {
            y.left.parent = x;
        }
        y.parent = x.parent;
        if (x.parent == null) {
            this.root = y;
        } else {
            if (x.parent.left == x) {
                x.parent.left = y;
            } else {
                x.parent.right = y;
            }
        }
        y.left = x;
        x.parent = y;
    }

    //右旋
    private void rightRotate(RBNode<T> y) {
        RBNode<T> x = y.left;
        y.left = x.right;
        if (x.right != null) {
            x.right.parent = y;
        }
        x.parent = y.parent;
        if (y.parent == null) {
            this.root = x;
        } else {
            if (y == y.parent.right) {
                y.parent.right = x;
            } else {
                y.parent.left = x;
            }
        }
        x.right = y;
        y.parent = x;
    }

    //获取节点的父节点
    private RBNode<T> parentOf(RBNode<T> node) {
        return node != null ? node.parent : null;
    }

    //判断节点是否是红色
    private boolean isRed(RBNode<T> node) {
        return (node != null) && node.color;
    }

    //设置节点为红色
    private void setRed(RBNode<T> node) {
        if (node != null) {
            node.color = true;
        }
    }

    //设置节点为黑色
    private void setBlack(RBNode<T> node) {
        if (node != null) {
            node.color = false;
        }
    }
}