每次面试都被问，什么是红黑树？

前言

理解红黑树需要掌握下面知识

二分查找算法
二叉查找树
自平衡树（AVL树和红黑树）

基于二分算法设计出了二叉查找树，为了弥补二叉查找树倾斜缺点，又出现了一些自平衡树，比如AVL树，红黑树等。

二分查找算法

在40亿数据中查找一个指定数据最多只需要32次，这就是二分查找算法的魅力。

二分查找算法（又叫折半查找算法）是一种在有序数组中查找某一特定元素的搜索算法。注意有序数组的前提。

下图中查找 4 ，查找从中间元素开始 4 < 7 ，从左边查找 4 > 3 ，从右边查找 4 < 6，然后找到元素。

二分查找算法时间和空间复杂度，$ {n} $ 是数组长度。

平均时间复杂度 $ {O(\log n)} $

最坏时间复杂度 $ {O(\log n)} $

最优时间复杂度 $ {O(1)} $

循环空间复杂度 $ {O(1)} $

递归空间复杂度 $ {O(\log n)} $

Java 递归实现二分查找。

    public static int binarySearch(int[] arr, int start, int end, int hkey) {
        if (start > end) {
            return -1;
        }
        int mid = start + (end - start) / 2;    //防止溢位
        if (arr[mid] > hkey) {
            return binarySearch(arr, start, mid - 1, hkey);
        }
        if (arr[mid] < hkey) {
            return binarySearch(arr, mid + 1, end, hkey);
        }
        return mid;
    }

Java 循环实现二分查找。

    public static int binarySearch(int[] arr, int start, int end, int hkey) {
        int result = -1;
        while (start <= end) {
            int mid = start + (end - start) / 2;    //防止溢位
            if (arr[mid] > hkey) {
                end = mid - 1;
            } else if (arr[mid] < hkey) {
                start = mid + 1;
            } else {
                result = mid;
                break;
            }
        }
        return result;
    }

二叉查找树

二叉查找树（Binary Search Tree，简称BST）是一棵二叉树，它具有以下性质：

若任意节点的左子树不空，则左子树上所有节点的值都小于它的根节点的值；
若任意节点的右子树不空，则右子树上所有节点的值都大于它的根节点的值；
任意节点的左、右子树也分别为二叉查找树。

二叉树：每个节点最多只有两个分支，分别称为“左子树”或“右子树”。

二叉查找树操作（搜索，插入，删除）效率依赖树高度。

最坏情况，树向一边倾斜，树高度 $n$ （节点数量），此时操作时间复杂度为 $O(n)$

理想情况，树高度 $log(n)$ ，操作时间复杂度 $O(log(n))$ ，此时它是一棵平衡的二叉查找树。

算法	平均	最差
空间	O(n)	O(n)
搜索	O(log n)	O(n)
插入	O(log n)	O(n)
删除	O(log n)	O(n)

为了让二叉查找树尽可能达到理想情况，出现了一些自平衡二叉查找树，如AVL树和红黑树。

AVL树

AVL树中的每个节点都有一个平衡因子属性（左子树高度减去右子树高度）。每次元素插入删除操作后，会重新进行平衡计算，如果节点平衡因子不为 [1,0,-1] 时，需要通过旋转使树到达平衡。AVL 树中有 4 种旋转操作。

左旋（Left Rotation）
右旋（RightRotation）
左右旋转（Left-Right Rotation）
左右旋转（Right-Left Rotation）

下面是 Java AVL 树的例子

    private Node insert(Node node, int key) {
          .....
        return rebalance(node); // 重新平衡计算
    }

    private Node delete(Node node, int key) {
          .....
        node = rebalance(node); // 重新平衡计算
        return node;
    }

        private Node rebalance(Node z) {
        updateHeight(z);
        int balance = getBalance(z);
        if (balance > 1) {
            if (height(z.right.right) > height(z.right.left)) {
                z = rotateLeft(z);
            } else {
                z.right = rotateRight(z.right);
                z = rotateLeft(z);
            }
        } else if (balance < -1) {
            if (height(z.left.left) > height(z.left.right)) {
                z = rotateRight(z);
            } else {
                z.left = rotateLeft(z.left);
                z = rotateRight(z);
            }
        }
        return z;
    }

https://github.com/eugenp/tut...

红黑树

性质

红黑树中的每个节点都有一个颜色属性。每次元素插入删除操作后，会进行重新着色和旋转达到平衡。

红黑树属于二叉查找树，它包含二叉查找树性质，同时还包含以下性质：

每个节点要么是黑色，要么是红色。
所有的叶子节点（NIL）被认为是黑色的。
每个红色节点的两个子节点一定都是黑色（不会出现两个连续红色节点）。
从根到叶子节点（NIL）的每条路径都包含相同数量的黑色节点。

查找

查找不会破坏树的平衡，逻辑也比较简单，通常有以下几个步骤。

从根节点开始查找，把根节点设置为当前节点；
当前节点为空，返回null；
当前节点不为空，查找key小于当前节点key，左子节点设为当前节点。
当前节点不为空，查找key大于当前节点key，右子节点设为当前节点。
当前节点不为空，查找key等于当前节点key，返回当前节点。

代码实现可以参考 Java 里面的 TreeMap。

    Entry p = root;
    while (p != null) {
        int cmp = k.compareTo(p.key);
        if (cmp < 0){
            p = p.left;
    }else if (cmp > 0){
      p = p.right;
    }else{
          return p;
    }
  }
    return null;

插入

插入操作分两大块：一查找插入位置；二插入后自平衡。

将根节点赋给当前节点，循环查找插入位置的节点；
当查找key等于当前节点key，更新节点存储的值，返回；
当查找key小于当前节点key，把当前节点的左子节点设置为当前节点；
当查找key大于当前节点key，把当前节点的右子节点设置为当前节点；
循环结束后，构造新节点作为当前节点左(右)子节点；
通过旋转变色进行自平衡。

代码实现可以参考 Java 里面的 TreeMap。

    Entry t = root;
  Entry parent;
    int cmp;
    do {
        parent = t;
        cmp = k.compareTo(t.key);
    if (cmp < 0){
            t = t.left; 
    }else if (cmp > 0){
            t = t.right;
    }else {
            return t.setValue(value);   // 更新节点的值，返回
    }
  } while (t != null);

    Entry e = new Entry<>(key, value, parent);
        if (cmp < 0){
          parent.left = e;
        }else {
            parent.right = e;  
    }
  fixAfterInsertion(e); // 通过旋转变色自平衡

插入场景分析