手写红黑树详解：美团Android岗面试真题解析

Android

2023-10-05 08:53:51

红黑树：美团 Android 岗面试的必备算法基础

什么是红黑树？

想象一下一个有序的树形结构，其中每个节点要么是红色的，要么是黑色的。这就是红黑树！它是一种巧妙设计的数据结构，既能保持平衡，又能快速执行搜索、插入和删除操作。它的特点包括：

根节点： 永远是黑色的，就像树上的树干一样，稳如泰山。
叶节点： 总是黑色，就像树叶一样，不可再分。
黑色高度： 从节点到任何叶节点的黑色节点数量相同，保持树的平衡。

红黑树的平衡艺术

红黑树的平衡不是巧合，而是通过一系列操作来实现的，就像树的修剪一样。当插入或删除节点时，树会自动进行以下操作：

颜色翻转： 将节点的颜色从红色变为黑色，反之亦然，就像给节点重新粉刷一样。
左旋： 就像用左脚踢球一样，将一个节点的左子树旋转到右子树上。
右旋： 与左旋相反，将一个节点的右子树旋转到左子树上。

红黑树的实现

用代码实现红黑树并不复杂。让我们以递归为例：

class Node {
    int key;
    Color color;
    Node left, right;
}

class RedBlackTree {
    Node root;

    // 插入节点
    void insert(int key) {
        root = insert(root, key);
    }

    // 插入节点（递归）
    private Node insert(Node node, int key) {
        // 递归基线：节点为空，创建新节点
        if (node == null) {
            return new Node(key, Color.RED);
        }

        // 小于当前节点，插入到左子树
        if (key < node.key) {
            node.left = insert(node.left, key);
        }
        // 大于等于当前节点，插入到右子树
        else {
            node.right = insert(node.right, key);
        }

        // 调整树的平衡
        return balance(node);
    }

    // 删除节点
    void delete(int key) {
        root = delete(root, key);
    }

    // 删除节点（递归）
    private Node delete(Node node, int key) {
        // 递归基线：节点为空，直接返回
        if (node == null) {
            return null;
        }

        // 小于当前节点，从左子树删除
        if (key < node.key) {
            node.left = delete(node.left, key);
        }
        // 大于等于当前节点，从右子树删除
        else if (key > node.key) {
            node.right = delete(node.right, key);
        }
        // 找到待删除节点，用最小后继节点替换
        else {
            if (node.left == null) {
                return node.right;
            } else if (node.right == null) {
                return node.left;
            }
            Node minNode = findMin(node.right);
            node.key = minNode.key;
            node.right = delete(node.right, minNode.key);
        }

        // 调整树的平衡
        return balance(node);
    }

    // 查找最小值
    int findMin() {
        return findMin(root).key;
    }

    // 查找最小值（递归）
    private Node findMin(Node node) {
        if (node == null) {
            return null;
        }
        while (node.left != null) {
            node = node.left;
        }
        return node;
    }

    // 查找最大值
    int findMax() {
        return findMax(root).key;
    }

    // 查找最大值（递归）
    private Node findMax(Node node) {
        if (node == null) {
            return null;
        }
        while (node.right != null) {
            node = node.right;
        }
        return node;
    }

    // 查找特定值
    boolean contains(int key) {
        return contains(root, key);
    }

    // 查找特定值（递归）
    private boolean contains(Node node, int key) {
        if (node == null) {
            return false;
        }
        if (key < node.key) {
            return contains(node.left, key);
        } else if (key > node.key) {
            return contains(node.right, key);
        } else {
            return true;
        }
    }

    // 平衡树
    private Node balance(Node node) {
        // 规则 1：根节点永远是黑色
        if (node == null) {
            return null;
        }
        if (node.color == Color.RED) {
            node.color = Color.BLACK;
        }

        // 规则 2：兄弟节点不能同时为红色
        if (isRed(node.left) && isRed(node.right)) {
            flipColors(node);
        }

        // 规则 3：如果左子树红色且右子树黑色，则左旋
        if (isRed(node.left) && isBlack(node.right)) {
            node = rightRotate(node);
        }

        // 规则 4：如果右子树红色且左子树黑色，则右旋
        if (isBlack(node.left) && isRed(node.right)) {
            node = leftRotate(node);
        }

        return node;
    }

    // 节点颜色判断
    private boolean isRed(Node node) {
        return node != null && node.color == Color.RED;
    }

    private boolean isBlack(Node node) {
        return node == null || node.color == Color.BLACK;
    }

    // 颜色翻转
    private void flipColors(Node node) {
        node.color = Color.BLACK;
        node.left.color = Color.RED;
        node.right.color = Color.RED;
    }

    // 左旋
    private Node leftRotate(Node node) {
        Node newRoot = node.right;
        node.right = newRoot.left;
        newRoot.left = node;
        return newRoot;
    }

    // 右旋
    private Node rightRotate(Node node) {
        Node newRoot = node.left;
        node.left = newRoot.right;
        newRoot.right = node;
        return newRoot;
    }
}