【数据结构与算法】第十、十一、十二章：平衡树（2-3查找树、红黑树）B树、B+树

10、平衡树

之前的二叉查找树，查询效率比单纯的链表和数组的查询效率要高很多，大部分情况下，确实是这样的，但在最坏情况下，二叉查找树的性能还是很糟糕
例如：依次往二叉查找树中插入9,8,7,6,5,4,3,2,1这9个数据，那么最终构造出来的树是长得下面这个样子：

如果要查找1这个元素，查找的效率依旧会很低。效率低的原因在于这个树并不平衡，全部是向左边分支，如果有一种方法，能够不受插入数据的影响，让生成的树都像完全二叉树那样，那么即使在最坏情况下，查找的效率依旧会很好

10.1、2-3查找树

为了保证查找树的平衡性，需要一些灵活性，因此在这里允许树中的 一个结点保存多个键

确切的说，将一棵标准的二叉查找树中的结点称为 2-结点 (含有一个键和两条链)

而现在引入 3-结点，它含有两个键和三条链

2-结点 和 3-结点 中的每条链都对应着其中保存的键所分割产生的一个区间

1）定义

一棵 2-3查找树 要么为空，要么满足下面两个要求：

• 2-结点

  • 含有 一个键 (及其对应的值)和 两条链
  • 左链接指向2-3树中的键都 小于 该结点
  • 右链接指向的2-3树中的键都 大于 该结点

• 3-结点

  • 含有 两个键 (及其对应的值)和 三条链
  • 左链接指向的2-3树中的键都 小于 该结点
  • 中链接指向的2-3树中的键都位于该结点的两个键 之间
  • 右链接指向的2-3树中的键都 大于 该结点

2）查找

• 类似于二叉查找树的查找算法
• 要判断一个键是否在树中，先将它和根结点中的键比较。如果它和其中任意一个相等，查找命中；否则就根据比较的结果找到指向相应区间的连接，并在其指向的子树中递归地继续查找。如果这个是空链接，查找未命中

3）插入

• 向2-结点中插入新键

  往 2-3树 中插入元素和往 二叉查找树 中插入元素一样

  首先要进行查找，然后将节点挂到未找到的节点上。2-3树之所以能够保证在最差的情况下的效率的原因在于其插入之后仍然能够保持平衡状态。

  如果查找后未找到的节点是一个2-结点，那么很容易，只需要将新的元素放到这个2-结点里面使其变成一个3-结点即可。但是如果查找的节点结束于一个3-结点，那么可能有点麻烦

• 向一棵只含有一个3-结点的树中插入新键

  假设2-3树只包含一个3-结点，这个结点有两个键，没有空间来插入第三个键了，最自然的方式是假设这个结点能存放三个元素，暂时使其变成一个4-结点，同时它包含四条链接

  然后，将这个4-结点的中间元素提升，左边的键作为其左子结点，右边的键作为其右子结点。插入完成，变为平衡2-3查找树，树的高度从0变为1

• 向一个父结点为2-结点的3-结点中插入新键

  和上面的情况一样，也可以将新的元素插入到3-结点中，使其成为一个临时的4-结点，然后，将该结点中 的中间元素提升到父结点(即2-结点)中，使其父结点成为一个3-结点，然后将左右结点分别挂在这个3-结点的恰当位置

• 向一个父结点为3-结点的3-结点中插入新键

  当插入的结点是3-结点的时候，将该结点拆分，中间元素提升至父结点，但是此时父结点是一个3-结点， 插入之后，父结点变成了4-结点，然后继续将中间元素提升至其父结点，直至遇到一个父结点是2-结点，然后将其变为3-结点，不需要继续进行拆分

• 分解根结点

  当插入结点到根结点的路径上全部是3-结点的时候，最终的根结点会变成一个临时的4-结点，此时，就需要将根结点拆分为两个2-结点，树的高度加1

4）性质

通过对2-3树插入操作的分析，发现在插入的时候，2-3树需要做一些局部的变换来保持2-3树的平衡

一棵完全平衡的2-3树具有以下性质：

• 任意 空链接 到根结点的路径长度都是 相等 的
• 4-结点变换为3-结点时，树的高度不会发生变化，只有当根结点是临时的4-结点，分解根结点时树高+1
• 2-3树与普通二叉查找树最大的区别在于，普通的二叉查找树是自顶向下生长，而2-3树是 自底向上 生长

5）实现

• 直接实现2-3树比较复杂，因为：
  • 需要处理不同的结点类型，非常繁琐
  • 需要多次比较操作来将结点下移
  • 需要上移来拆分4-结点
  • 拆分4-结点的情况有很多种

2-3查找树实现起来比较复杂，在某些情况插入后的平衡操作可能会使得效率降低。但是2-3查找树作为一种比较重要的概念和思路对于后面要讲到的红黑树、B树和B+树非常重要

10.2、2-3-4树 与 红黑树

1）与红黑树等价关系

2）转化为红黑树

一棵2-3-4树可以有多棵红黑树，一个红黑树只有一个2-3-4树

3）添加

思路：先添加、再调整

• 新增结点都是红色
• 都是从叶子节点新增

需要调整的四种情况：

• 左左：/
  • 一根斜线(此时最好用手比划一下)，顶点表示祖节点，中间点表示父节点，底点表示插入节点
• 右右: \
  • 一根反斜线，表示同上
• 左右：<
  • 一个小于号，顶点表示祖节点，中间尖点表示父节点，底点表示插入节点
• 右左：>
  • 一个大于号，表示同上

4）添加后调整

TreeMap 源码

在线演示：https://www.cs.usfca.edu/~galles/visualization/RedBlack.html

5）删除

思路：先删除、再调整

6）删除后调整

见另一篇博文
【手撕红黑树 | 史上最详细注解】增删查改 原理剖析 代码实现

10.3、红黑树

2-3树能保证在插入元素之后，树依然保持平衡状态，它的最坏情况下所有子结点都是2-结点，树的高度为lgN，相比于普通的二叉查找树，最坏情况下树的高度为N，确实保证了最坏情况下的时间复杂度，但是2-3树实现起来过于复杂，所以介绍一种2-3树思想的简单实现：红黑树

• 红黑树主要是对2-3树进行编码，红黑树背后的基本思想是：

  • 用 标准的二叉查找树 (完全由2-结点构成)和一些 额外的信息 (替换3-结点)来表示2-3树

• 将树中的链接分为两种类型

  • 红链接：将两个2-结点连接起来构成一个3-结点
  • 黑链接：则是2-3树中的普通链接

• 确切的说，将 3-结点 表示为由一条 左斜的红色链接 相连的两个2-结点

  两个2-结点：其中一个是另一个的左子结点

• 优点：无需修改就可以直接使用标准的二叉查找树的get方法

1）定义

红黑树是 含有红黑链接 并满足下列条件的 二叉查找树：

• 红链接均为 左链接
• 没有任何一个结点同时和两条红链接相连
• 该树是完美 黑色平衡 的，即任意空链接到根结点的路径上的黑链接数量相同

下面是红黑树与2-3树的对应关系：

以下是另一个版本解读

2）结点API

因为每个结点（根结点除外）都只会有一条指向自己的链接（从它的父结点指向它），可以在之前的Node结点中添加一个布尔类型的变量 color 来表示链接的颜色。如果指向它的链接是红色的，那么该变量的值为true，如果链接是黑色的，那么该变量的值为false

package chapter10;

/**
 * @author 土味儿
 * Date 2021/9/10
 * @version 1.0
 * 红黑树结点类
 */
public class Node<K,V> {
    /**
     * 键 key
     */
    private K key;
    /**
     * 值 value
     */
    private V value;
    /**
     * 左子结点
     */
    private Node left;
    /**
     * 右子结点
     */
    private Node right;
    /**
     * 指向该结点的父结点链接颜色
     * 红色：true
     * 黑色：false
     */
    private boolean color;

    /**
     * 构造器
     * @param key
     * @param value
     * @param left
     * @param right
     * @param color
     */
    public Node(K key, V value, Node left, Node right, boolean color) {
        this.key = key;
        this.value = value;
        this.left = left;
        this.right = right;
        this.color = color;
    }
}

3）平衡化

在对红黑树进行一些增删改查的操作后，很有可能会出现红色的右链接或者两条连续红色的链接，而这些都不满足红黑树的定义，所以需要对这些情况通过旋转进行修复，让红黑树保持平衡

1、左旋

当某个结点的左子结点为黑色，右子结点为红色，此时需要左旋

左黑右红

前提：当前结点为h，它的右子结点为x

• 左旋过程
  • 让x的左子结点变为h的右子结点：h.right = x.left
  • 让h成为x的左子结点：x.left = h
  • 把h的color属性赋给x的color属性值：x.color = h.color
  • 把 h 的color变为：RED

---

左旋初始：

左旋过程：

左旋结束：

---

2、右旋

当某个结点的左子结点是红色，且左子结点的左子结点也是红色，需要右旋

左子左孙都红

前提：当前结点为h，它的左子结点为x

• 右旋过程
  • 让x的右子结点成为h的左子结点：h.left = x.right
  • 让h成为x的右子结点：x.right = h
  • 把h的color属性赋给x的color属性值：x.color = h.color
  • 把 h 的color变为：RED

右旋后x结点仍然与两条红链接相连，可以通过后续颜色反转解决

---

右旋初始：

右旋过程：

右旋结束：

---

4）向单个2-结点插入新键

一棵只含有一个键的红黑树只含有一个2-结点。插入另一个键后， 可能就需要旋转

• 如果新键小于当前结点的键

  只需要新增一个红色结点即可

  新的红黑树和单个3-结点完全等价

• 如果新键大于当前结点的键

  那么新增的红色结点将会产生一条红色的右链接，此时需要通过 左旋，把红色右链接变成左链接，插入操作才算完成

  形成的新的红黑树依然和3-结点等价，其中含有两个键，一条红色链接

5）向底部2-结点插入新键

用和二叉查找树相同的方式向一棵红黑树中插入一个新键， 会在树的底部新增一个结点（可以保证有序性），唯一区别的地方是会用红链接将新结点和它的父结点相连。如果它的父结点是一个2-结点，那么刚才上面的两种方式仍然适用

6）颜色反转

当一个结点的左子结点和右子结点的color都为RED时，也就是出现了临时的4-结点，此时只需要把左子结点和右子结点的颜色变为BLACK，同时让当前结点的颜色变为RED即可

左右都红

7）向一棵双键树插入新键

双键树：即一个3-结点的树

分为三种子情况

• 新键大于原树中的两个键

• 新键小于原树中的两个键

• 新键介于原树中两个键之间

8）根结点颜色总是黑色

在结点Node对象中color属性表示的是父结点指向当前结点的连接的颜色，由于 根结点不存在父结点，所以每次插入操作后，都需要把根结点的颜色设置为黑色

9）向树底部3-结点插入新键

假设在树的底部的一个3-结点下加入一个新的结点

前面的3种情况都可能会出现

• 右链接：只需要转换颜色即可
• 左链接：需要进行右旋，然后再转换颜色
• 中链接：需要先左旋，然后再右旋，最后转换颜色

颜色转换会使中间结点的颜色变红，相当于将它送入了父结点。这意味着父结点中继续插入一个新键，只需要使用相同的方法解决即可，直到遇到一个2-结点或者根结点为止

10）API

11）实现

package chapter10;

/**
 * @author 土味儿
 * Date 2021/9/10
 * @version 1.0
 * 红黑树
 */
public class RedBlackTree<K extends Comparable<K>, V> {
    /**
     * 根结点
     */
    private Node root;
    /**
     * 元素数量
     */
    private int n;
    /**
     * 红色链接
     */
    private static final boolean RED = true;
    /**
     * 黑色链接
     */
    private static final boolean BLACK = false;

    /**
     * 构造器
     */
    public RedBlackTree() {
        //this.root = new Node(null, null, null, null, BLACK);
        this.n = 0;
    }


    /**
     * 判断结点 x 的父指向链接是否为红色
     *
     * @param x
     * @return
     */
    private boolean isRed(Node x) {
        if (x != null) {
            return x.color == RED;
        }
        return false;
    }

    /**
     * 对 h 结点左旋
     * -------------------------------------
     *      H                       X
     *    /  \\                   // \
     *   a    X      左旋后>      H    c
     *      /  \               /  \
     *     b    c             a    b
     * -------------------------------------
     *
     * @param h
     * @return
     */
    private Node rotateLeft(Node h) {
        // 参数有效性检测
        if (h == null || h.right == null) {
            return null;
        }

        // 当前结点为 h，它的右子结点为 x
        Node x = h.right;

        // 让 x 的左子结点变为 h 的右子结点：h.right = x.left
        h.right = x.left;

        // 让 h 成为 x 的左子结点：x.left = h
        x.left = h;

        // 把 h 的color赋给 x 的color值：x.color = h.color
        x.color = h.color;

        // 把 h 的color变为 RED
        h.color = RED;

        return x;
    }

    /**
     * 对 h 结点右旋
     * 右旋后仍然有结点与两条红链接相连，需要颜色反转
     * -------------------------------------
     *         H                  X
     *       // \               // \\
     *      X    c    右旋后>   a     H
     *    // \                      / \
     *   a    b                    b   c
     * -------------------------------------
     *
     * @param h
     * @return
     */
    private Node rotateRight(Node h) {
        // 参数有效性检测
        if (h == null || h.left == null) {
            return null;
        }

        // 当前结点为 h ，它的左子结点为 x
        Node x = h.left;

        // 让 x 的右子结点变为 h 的左子结点
        h.left = x.right;

        // 让 h 成为 x 的右子结点
        x.right = h;

        // 把 h 的color赋给 x 的color：x.color = h.color
        x.color = h.color;

        // 把 h 的color变为：RED
        h.color = RED;

        return x;
    }

    /**
     * 对 h 结点颜色反转
     * 相当于拆分4-结点
     * ------------------------------------
     *        |               ||
     *        H      ===>     H
     *      // \\            / \
     *     a    b           a   b
     * ------------------------------------
     *
     * @param h
     */
    private void flipColors(Node h) {
        if (h == null) {
            return;
        }
        // 让 h 的左右子结点颜色变为黑色
        h.left.color = BLACK;
        h.right.color = BLACK;
        // 让 h 的颜色变为红色
        h.color = RED;
    }

    /**
     * 插入/修改元素
     *
     * @param key
     * @param value
     */
    public void put(K key, V value) {
        root = put(root, key, value);

        // 根结点总是黑色
        root.color = BLACK;
    }

    /**
     * 在 h 上插入元素，并返回新树
     *
     * @param h
     * @param key
     * @param value
     * @return
     */
    private Node put(Node h, K key, V value) {
        // 如果 h 为 null
        if (h == null) {
            // 数量加1
            n++;
            // 新建结点并返回
            return new Node(key, value, null, null, RED);
        }

        // 比较 key 与 h 结点的键的大小
        int cmp = key.compareTo(h.key);
        if (cmp < 0) {
            // 小于：向左子结点添加（递归）
            h.left = put(h.left, key, value);
        } else if (cmp > 0) {
            // 大于：向右子结点添加（递归）
            h.right = put(h.right, key, value);
        } else {
            // 等于：值替换
            h.value = value;
        }

        // 左旋：左黑右红
        if (!isRed(h.left) && isRed(h.right)) {
            h = rotateLeft(h);
        }

        // 右旋：左子左孙都红
        if (h.left != null && isRed(h.left) && isRed(h.left.left)) {
            h = rotateRight(h);
        }

        // 颜色反转：左右都红
        if (isRed(h.left) && isRed(h.right)) {
            flipColors(h);
        }

        // 返回新树h
        return h;
    }

    /**
     * 得到 key 的值
     *
     * @param key
     * @return
     */
    public V get(K key) {
        return get(root, key);
    }

    /**
     * 在 h 中得到 key 的值
     *
     * @param h
     * @param key
     * @return
     */
    private V get(Node h, K key) {
        if (h == null) {
            return null;
        }

        // 比较 key 与 h 键的大小
        int cmp = key.compareTo(h.key);
        if (cmp < 0) {
            // 小于：递归查找左子树
            return get(h.left, key);
        } else if (cmp > 0) {
            // 大于：递归查找右子树
            return get(h.right, key);
        } else {
            // 等于：返回 value
            return h.value;
        }
    }

    /**
     * 元素数量
     *
     * @return
     */
    public int size() {
        return n;
    }

    /**
     * 内部结点类
     */
    private class Node {
        /**
         * 键 key
         */
        private K key;
        /**
         * 值 value
         */
        private V value;
        /**
         * 左子结点
         */
        private Node left;
        /**
         * 右子结点
         */
        private Node right;
        /**
         * 指向该结点的父结点链接颜色
         * 红色：true
         * 黑色：false
         */
        private boolean color;

        /**
         * 构造器
         *
         * @param key
         * @param value
         * @param left
         * @param right
         * @param color
         */
        public Node(K key, V value, Node left, Node right, boolean color) {
            this.key = key;
            this.value = value;
            this.left = left;
            this.right = right;
            this.color = color;
        }
    }
}

package chapter10;

import org.junit.Test;

/**
 * @author 土味儿
 * Date 2021/9/10
 * @version 1.0
 * 测试红黑树
 */
public class RedBlackTreeTest {
    @Test
    public void test(){
        RedBlackTree<String, String> tree = new RedBlackTree<>();
        tree.put("3","张三");
        tree.put("2","王五");
        tree.put("7","田七");
        tree.put("4","李四");

        System.out.println(tree.size());
        System.out.println(tree.get("7"));

        tree.put("1","老大");
        System.out.println(tree.size());

        tree.put("3","三哥");
        System.out.println(tree.size());
        System.out.println(tree.get("3"));
    }
}

4
田七
5
5
三哥

10.4、Java类

java.util.TreeMap

11、B树

• 一个结点允许多于两个key的存在
• B树是一种树状数据结构，它能够存储数据、对其进行排序，并允许以 O(logn) 的时间复杂度进行查找、顺序读取、插入和删除等操作

11.1、B树的特征

• B树中允许一个结点中包含 多个key ，可以是3个、4个、5个甚至更多，并不确定，需要看具体的实现
• 选择一个参数M，来构造一个B树，可以把它称作是 M阶的B树，那么该树会具有如下特点：
  • 每个结点 最多有 M-1 个key，并且以 升序排列
  • 每个结点 最多能有 M 个子结点
  • 根结点至少有 两个 子结点

在实际应用中B树的阶数一般都比较大（通常大于100）， 所以，即使存储大量的数据，B树的高度仍然比较小，这样在某些应用场景下，就可以体现出它的优势

11.2、B树存储数据

例：M = 5，每个结点最多包含 4 个键值对

11.3、B树在磁盘文件中的应用

在程序中，不可避免的需要通过IO操作文件，而文件是存储在磁盘上的。计算机操作磁盘上的文件是通过文件系统进行操作的，在文件系统中就使用到了B树这种数据结构

1）磁盘

磁盘能够保存大量的数据，从GB一直到TB级，但读取速度比较慢，因为涉及到机器操作，读取速度为毫秒级

磁盘由盘片构成，每个盘片有两面，又称为盘面 。盘片中央有一个可以旋转的主轴，使得盘片以固定的旋转速率旋转，通常是5400rpm或者是7200rpm，一个磁盘中包含了多个这样的盘片并封装在一个密封的容器内 。盘片的每个表面是由一组称为磁道同心圆组成的 ，每个磁道被划分为一组扇区 ，每个扇区包含相等数量的数据位，通常是512个子节，扇区之间由一些间隙隔开，这些间隙中不存储数据

2）磁盘IO

• 磁盘用磁头来读写存储在盘片表面的位，而磁头连接到一个移动臂上，移动臂沿着盘片半径前后移动，可以将磁头定位到任何磁道上，这称之为寻道操作。一旦定位到磁道后，盘片转动，磁道上的每个位经过磁头时，读写磁头就可以感知到该位的值，也可以修改值。对磁盘的访问时间分为 寻道时间，旋转时间，以及 传送时间

• 由于存储介质的特性，磁盘本身存取就比主存慢很多，再加上机械运动耗时，因此为了提高效率，要尽量减少磁盘I/O，减少读写操作。 为了达到这个目的，磁盘往往不是严格按需读取，而是每次都会 预读，即使只需要一个字节，磁盘也会从这个位置开始，顺序向后读取一定长度的数据放入内存。这样做的理论依据是计算机科学中著名的 局部性原理：当一个数据被用到时，其附近的数据也通常会马上被使用。由于磁盘顺序读取的效率很高（不需要寻道时间，只需很少的旋转时间），因此预读可以提高I/O效率

• 页 是计算机管理存储器的 逻辑块，硬件及操作系统往往将主存和磁盘存储区分割为连续的大小相等的块，每个存储块称为一页（1024个字节或其整数倍），预读的长度一般为页的整倍数。主存和磁盘以页为单位交换数据。当程序要读取的数据不在主存中时，会触发一个缺页异常，此时系统会向磁盘发出读盘信号，磁盘会找到数据的起始位置并向后连续读取一页或几页载入内存中，然后异常返回，程序继续运行

• 文件系统的设计者利用了磁盘预读原理，将一个结点的大小设为等于一个页（1024个字节或其整数倍），这样每个结点只需要一次I/O就可以完全载入。那么3层的B树可以容纳1024 * 1024 * 1024差不多10亿个数据，如果换成二叉查找树，则需要30层！假定操作系统一次读取一个节点，并且根节点保留在内存中，那么B树在10亿个数据中查找目标值，只需要小于3次硬盘读取就可以找到目标值，但红黑树需要小于30次，因此B树大大提高了IO的操作效率

12、B+树

B+树是对B树的一种变形树，它与B树的差异在于：

1. 非叶结点仅具有索引作用，也就是说，非叶子结点只存储key，不存储value
2. 树的所有叶结点构成一个有序链表，可以按照 key 排序的次序遍历全部数据

12.1、B+树存储数据

例：M = 5，那么每个结点最多包含4个键值对

12.2、B+树和B树的对比

• B+ 树的优点在于：
  • 由于B+树在非叶子结点上不包含真正的数据，只当做索引使用，因此在内存相同的情况下，能够存放更多的key
  • B+树的叶子结点都是 相连 的，因此对整棵树的遍历只需要一次线性遍历叶子结点即可。而且由于数据顺序排列并且相连，所以便于 区间查找和搜索。而B树则需要进行每一层的递归遍历
• B树的优点在于：
  • 由于B树的每一个节点都包含key和value，因此根据key查找value时，只需要找到key所在的位置，就能找到value，但B+树只有叶子结点存储数据，索引每一次查找，都必须一次一次，一直找到树的最大深度处，也就是叶子结点的深度，才能找到value

12.3、B+树在数据库中的应用

在数据库的操作中，查询操作可以说是最频繁的一种操作，因此在设计数据库时，必须要考虑到查询的效率问题，在很多数据库中，都是用到了B+树来提高查询的效率；在操作数据库时，为了提高查询效率，可以基于某张表的某个字段建立 索引，就可以提高查询效率，那其实这个 索引就是B+树这种数据结构实现的

1）未建立主键索引查询

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zcfm6TKu-1631976329182)(数据结构与算法.assets/image-20210914210020062.png)]

执行

select * from user where id = 18

需要从第一条数据开始，一直查询到第6条，发现id=18，此时才能查询出目标结果，共需要比较6次

2）建立主键索引查询

3）区间查询

执行

select * from user where id>=12 and id<=18

如果有了索引，由于B+树的叶子结点形成了一个 有序链表， 所以只需要找到id为12的叶子结点，按照遍历链表的方式顺序往后查即可，效率非常高