B 树和 B + 树：数据结构的深度解析

目录

B 树和 B + 树：数据结构的深度解析

一、引言

二、B 树和 B + 树的基本概念

（一）从二叉树到 B 树

（二）B + 树与 B 树的区别

三、B 树和 B + 树的应用场景

四、为何使用 B 树或 B + 树作为索引结构

五、B 树和 B + 树的特点总结

（一）B 树特点

（二）B + 树特点

六、学习建议

二叉树节点定义示例

二叉查找树插入节点示例方法

平衡二叉树（AVL 树）节点定义及左旋右旋示例方法（简化示意，实际更复杂）

B 树节点定义示例（简化示意，未包含完整 B 树操作逻辑）

B + 树节点定义示例（简化示意，未包含完整 B + 树操作逻辑）

---

一、引言

在数据结构与算法领域，B 树和 B + 树是常常被提及的重要概念。不少小伙伴对它们存在疑惑，甚至质疑其在实际工作中的用处，以及为何面试中经常出现相关问题。今天，我们就来深入剖析 B 树和 B + 树，解答这些疑问，并分享一些相关的学习资源。

二、B 树和 B + 树的基本概念

（一）从二叉树到 B 树

1. 二叉树：是一种每个节点最多支持两个分支的树结构，相比单向链表多了一个分支。二叉查找树在二叉树的基础上增加了规则，即左子树所有节点值小于根节点，右子树所有节点值大于根节点。但二叉查找树可能出现斜树问题，导致时间复杂度增加。
2. 平衡二叉树（AVL 树）：具有二叉查找树的所有特点，同时规定左右两个子树的高度差绝对值不能超过 1。它通过左旋和右旋的方式来维持平衡。
3. B 树：是一种多路平衡查找树，满足平衡二叉树的规则，但可以有多个子树。子树的数量取决于关键字的数量，比如根节点有两个关键字，那么它能拥有的子树数量是关键字数量加 1。在存储同样数据量的情况下，平衡二叉树的高度要大于 B 树。

以下是根据上述视频内容涉及的部分概念，编写的一些相关 Java 示例代码，用于辅助理解其中提到的数据结构相关内容：

二叉树节点定义示例

class BinaryTreeNode {
    int value;
    BinaryTreeNode left;
    BinaryTreeNode right;

    public BinaryTreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

二叉查找树插入节点示例方法

class BinarySearchTree {
    private BinaryTreeNode root;

    public void insert(int value) {
        root = insertRecursive(root, value);
    }

    private BinaryTreeNode insertRecursive(BinaryTreeNode current, int value) {
        if (current == null) {
            return new BinaryTreeNode(value);
        }

        if (value < current.value) {
            current.left = insertRecursive(current.left, value);
        } else if (value > current.value) {
            current.right = insertRecursive(current.right, value);
        }

        return current;
    }
}

平衡二叉树（AVL 树）节点定义及左旋右旋示例方法（简化示意，实际更复杂）

class AVLTreeNode {
    int value;
    AVLTreeNode left;
    AVLTreeNode right;
    int height;

    public AVLTreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
        this.height = 1;
    }
}

class AVLTree {
    private AVLTreeNode root;

    // 获取节点高度
    private int height(AVLTreeNode node) {
        if (node == null) {
            return 0;
        }
        return node.height;
    }

    // 获取平衡因子
    private int getBalanceFactor(AVLTreeNode node) {
        if (node == null) {
            return 0;
        }
        return height(node.left) - height(node.right);
    }

    // 右旋操作（简化示意）
    private AVLTreeNode rightRotate(AVLTreeNode y) {
        AVLTreeNode x = y.left;
        AVLTreeNode T2 = x.right;

        x.right = y;
        y.left = T2;

        y.height = Math.max(height(y.left), height(y.right)) + 1;
        x.height = Math.max(height(x.left), height(x.right)) + 1;

        return x;
    }

    // 左旋操作（简化示意）
    private AVLTreeNode leftRotate(AVLTreeNode x) {
        AVLTreeNode y = x.right;
        AVLTreeNode T2 = y.left;

        y.left = x;
        x.right = T2;

        x.height = Math.max(height(x.left), height(x.right)) + 1;
        y.height = Math.max(height(y.left), height(y.right)) + 1;

        return y;
    }

    // 插入节点并保持平衡（简化示意，实际需更多处理）
    public void insert(int value) {
        root = insertRecursive(root, value);
    }

    private AVLTreeNode insertRecursive(AVLTreeNode current, int value) {
        if (current == null) {
            return new AVLTreeNode(value);
        }

        if (value < current.value) {
            current.left = insertRecursive(current.left, value);
        } else if (value > current.value) {
            current.right = insertRecursive(current.right, value);
        } else {
            // 不允许插入重复值，这里可根据实际需求处理
            return current;
        }

        current.height = 1 + Math.max(height(current.left), height(current.right));

        int balanceFactor = getBalanceFactor(current);

        // 左左情况
        if (balanceFactor > 1 && value < current.left.value) {
            return rightRotate(current);
        }

        // 右右情况
        if (balanceFactor < -1 && value > current.right.value) {
            return leftRotate(current);
        }

        // 左右情况
        if (balanceFactor > 1 && value > current.left.value) {
            current.left = leftRotate(current.left);
            return rightRotate(current);
        }

        // 右左情况
        if (balanceFactor < -1 && value < current.right.value) {
            current.right = rightRotate(current.right);
            return leftRotate(current);
        }

        return current;
    }
}

B 树节点定义示例（简化示意，未包含完整 B 树操作逻辑）

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

class BTreeNode {
    // 存储关键字
    List keys = new ArrayList<>();
    // 存储子节点
    List children = new ArrayList<>();
    boolean isLeaf;

    public BTreeNode(boolean isLeaf) {
        this.isLeaf = isLeaf;
    }

    // 添加关键字
    public void addKey(int key) {
        keys.add(key);
    }

    // 添加子节点
    public void addChild(BTreeNode child) {
        children.add(child);
    }
}

B + 树节点定义示例（简化示意，未包含完整 B + 树操作逻辑）

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

class BPlusTreeNode {
    // 存储关键字
    List keys = new ArrayList<>();
    // 存储指向子节点的指针（非叶子节点）或数据（叶子节点）
    List