JavaDS —— B树

已于 2024-09-15 18:01:59 修改
阅读量615 收藏 33
点赞数 41
分类专栏： JavaDS 文章标签： b树 数据结构 java
于 2024-09-15 18:00:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liwuqianhzc/article/details/142282826
版权

前言

本章节将带领大家进入B树的学习，主要介绍B树的概念和B树的插入代码的实现，删除代码不做讲解，最后简单介绍B+树和B*树。

B树的概念

1970年，R.Bayer和E.mccreight提出了一种适合外查找的树，它是一种平衡的多叉树，称为B树(有些地方写的是B-树，注意不要误读成"B减树")。

如果B树是一颗三叉平衡树的话，上面一层是关键字区域，下面一层存放的是孩子结点：
在这里插入图片描述

我们来直观感受一下插入的过程：

B树的插入过程

一棵M阶(M>2)的B树，是一棵平衡的M路平衡搜索树，可以是空树或者满足一下性质：

  1. 根节点至少有两个孩子
  2. 每个非根节点至少有 【M/2(向上取整) - 1】 个关键字,至多有M-1个关键字，并且以升序排列
  3. 每个非根节点至少有【M/2(向上取整)】个孩子,至多有M个孩子
  4. key[i]和key[i+1]之间的孩子节点的值介于key[i]、key[i+1]之间
  5. 所有的叶子节点都在同一层

B树的实现

这里实现B树的插入代码。

结点定义

这里以三叉树为演示例子，定义 M 为 3，在结点初始化的时候，我们分别在keys 和 subs 域都增加一个空间，这样会方便我们后续的结点分裂。

    public static final int M = 3;
    public Node root;

    static class Node {
        public int[] keys;//关键字
        public Node[] subs;//孩子结点
        public Node parent;//双亲结点
        public int usedSize;//使用的空间个数

        public Node() {
            //多分配一个空间是为了后面便于我们分裂结点
            this.keys = new int[M];
            this.subs = new Node[M+1];
        }
    }

插入分析

首先如果根节点为空的话，直接插入即可：

//根节点为空，直接插入
        if(root == null) {
            root = new Node();
            root.keys[0] = key;
            root.usedSize = 1;
            return;
        }

然后这里我们实现的B树是不能插入相同的数据的，所以我们需要先查找是否已经存在过 key 值，先写一个查找代码：

当遇到和key 值是一样的情况下，我们直接返回即可，如果没有遇到，我们需要继续查找下去。

结点的 keys 是连续的数组，我们需要遍历这个数组：
如果发现 key 大于数组元素，需要继续向后遍历，如果发现 key 小于数组元素，我们则需要进入到对应的孩子结点继续寻找 key 。

最后我们要考虑返回值，我们应该返回什么样的数据？
如果至少单纯判断是否存在，也就是返回布尔值，如果存在某个数据就是返回true，这时候是不需要进行插入操作的，但是如果不存在，你返回的是 false ，那我们应该从哪个结点进行插入操作，所以我们需要获得具体的结点，这时候就需要在查找的循环过程中保存上一个 cur 结点，当cur 走到空的时候，cur 的上一个结点就是我们需要插入数据的结点了。

但是如果返回结点，那就意味着最后的返回值不可能为空，那就无法判断是否存在了 key，所以我们需要接收两个返回值，这时候我们可以定义一个泛型类，用来创建对象保存两个数据，一个是结点，一个是下标，当不存在的时候直接返回 -1。

public class Pair<K, V> {
    private K key;
    private V val;

    public Pair(K key, V val) {
        this.key = key;
        this.val = val;
    }

    public K getKey() {
        return key;
    }

    public void setKey(K key) {
        this.key = key;
    }

    public V getVal() {
        return val;
    }

    public void setVal(V val) {
        this.val = val;
    }
}


    //查找
    public Pair<Node,Integer> find(int key) {
        Node cur = root;
        Node prev = null;
        while(cur != null) {
            int i = 0;
            while(i < cur.usedSize) {
                if(cur.keys[i] == key) {
                    //存在该节点
                    return new Pair<>(cur,i);
                } else if(cur.keys[i] > key) {
                    //需要进入孩子结点继续查找
                    break;
                } else {
                    //继续查找
                    i++;
                }
            }
            prev = cur;
            cur = cur.subs[i];
        }

        //找不到，返回双亲结点
        return new Pair<>(prev,-1);
    }

如果不存在，我们就需要插入key ，在获取到的 prev 上进行直接插入，最后我们就要考虑是否超过了M，如果超过了M，就需要进行结点的分裂：

这里要注意的是，我们插入过程都是在叶子结点上进行的，所以不需要进行孩子域 subs 的调整。

        //不存在，需要进行插入
        Node cur = find.getKey();
        //插入是在叶子结点进行的，不需要调整孩子结点
        int i = cur.usedSize - 1;
        for (; i >= 0; i--) {
            if(cur.keys[i] > key) {
                cur.keys[i+1] = cur.keys[i];
            } else {
                break;
            }
        }
        cur.keys[i+1] = key;
        cur.usedSize++;

        //是否需要进行分裂
        if(cur.usedSize == M) {
            split(cur);
        }

分裂分析

我们来看一下非根结点的分裂过程：
在这里插入图片描述
我们需要获取中间的关键字，然后从中间的关键字的下一个开始拷贝到新结点上，然后中间的关键字需要提取到上面去，也就是需要调整 双亲结点将 中间值插入进去，最后调整三个结点即可。

由于你往双亲结点上插入了一个数据，所以可能导致双亲结点超过容量，所以最后还需要查看双亲结点是否需要进行分裂

		Node newNode = new Node();
        Node parent = cur.parent;

        //进行keys和孩子结点的拷贝
        int mid = M / 2;
        int i = 0;
        int j = mid + 1;
        for(; j < cur.usedSize; j++) {
            newNode.keys[i] = cur.keys[j];
            newNode.subs[i] = cur.subs[j];
            //如果拷贝过来的孩子结点不为空，需要修改孩子结点的双亲结点
            if(newNode.subs[i] != null) {
                newNode.subs[i].parent = newNode;
            }
            //usedSize 随之修改
            newNode.usedSize++;
            i++;
        }

        //还差一个孩子结点没有拷贝，再次拷贝孩子结点
        newNode.subs[i] = cur.subs[j];
        if(newNode.subs[i] != null) {
            newNode.subs[i].parent = newNode;
        }

        //新结点的双亲结点设置为 parent
        newNode.parent = parent;

        //设置 cur 的 usedSize 数值
        cur.usedSize = mid;

        //需要提取的中间关键字
        int midVal = cur.keys[mid];

        //特殊情况：当分裂的结点正好是根结点
        if(cur == root) {
            root = new Node();
            root.keys[0] = midVal;
            root.subs[0] = cur;
            root.subs[1] = newNode;
            cur.parent = newNode.parent = root;
            root.usedSize = 1;
            return;
        }

        //处理 parent 结点
        //将 cur 的中间关键值提到 parent;
        int end = parent.usedSize - 1;
        for(; end >= 0; end--) {
            if(parent.keys[end] > midVal) {
                parent.keys[end+1] = parent.keys[end];
                parent.subs[end+2] = parent.subs[end+1];
            } else {
                break;
            }
        }
        parent.keys[end+1] = midVal;
        parent.subs[end+2] = newNode;
        parent.usedSize++;

        //是否需要继续分裂
        if(parent.usedSize == M) {
            split(parent);
        }

如果分裂的是根节点的话，就有一点不一样了：我们需要为中间值创建一个新结点作为新的 根节点
在这里插入图片描述
在这里插入图片描述

		//特殊情况：当分裂的结点正好是根结点
        if(cur == root) {
            root = new Node();
            root.keys[0] = midVal;
            root.subs[0] = cur;
            root.subs[1] = newNode;
            cur.parent = newNode.parent = root;
            root.usedSize = 1;
            return;
        }

根节点的插入和非根结点的插入区别就在于中间值的处理，所以在前面拷贝的过程的代码可以保留，最后进行特殊情况的判断处理即可。

    private void split(Node cur) {
        Node newNode = new Node();
        Node parent = cur.parent;

        //进行keys和孩子结点的拷贝
        int mid = M / 2;
        int i = 0;
        int j = mid + 1;
        for(; j < cur.usedSize; j++) {
            newNode.keys[i] = cur.keys[j];
            newNode.subs[i] = cur.subs[j];
            //如果拷贝过来的孩子结点不为空，需要修改孩子结点的双亲结点
            if(newNode.subs[i] != null) {
                newNode.subs[i].parent = newNode;
            }
            //usedSize 随之修改
            newNode.usedSize++;
            i++;
        }

        //还差一个孩子结点没有拷贝，再次拷贝孩子结点
        newNode.subs[i] = cur.subs[j];
        if(newNode.subs[i] != null) {
            newNode.subs[i].parent = newNode;
        }

        //新结点的双亲结点设置为 parent
        newNode.parent = parent;

        //设置 cur 的 usedSize 数值
        cur.usedSize = mid;

        //需要提取的中间关键字
        int midVal = cur.keys[mid];

        //特殊情况：当分裂的结点正好是根结点
        if(cur == root) {
            root = new Node();
            root.keys[0] = midVal;
            root.subs[0] = cur;
            root.subs[1] = newNode;
            cur.parent = newNode.parent = root;
            root.usedSize = 1;
            return;
        }

        //处理 parent 结点
        //将 cur 的中间关键值提到 parent;
        int end = parent.usedSize - 1;
        for(; end >= 0; end--) {
            if(parent.keys[end] > midVal) {
                parent.keys[end+1] = parent.keys[end];
                parent.subs[end+2] = parent.subs[end+1];
            } else {
                break;
            }
        }
        parent.keys[end+1] = midVal;
        parent.subs[end+2] = newNode;
        parent.usedSize++;

        //是否需要继续分裂
        if(parent.usedSize == M) {
            split(parent);
        }
    }

最终代码

package mybtree;

public class Btree {

    public static final int M = 3;
    public Node root;

    static class Node {
        public int[] keys;//关键字
        public Node[] subs;//孩子结点
        public Node parent;//双亲结点
        public int usedSize;//使用的空间个数

        public Node() {
            //多分配一个空间是为了后面便于我们分裂结点
            this.keys = new int[M];
            this.subs = new Node[M+1];
        }
    }

    //插入
    public void insert(int key) {
        //根节点为空，直接插入
        if(root == null) {
            root = new Node();
            root.keys[0] = key;
            root.usedSize = 1;
            return;
        }

        //先查找是否存在key
        Pair<Node,Integer> find = find(key);

        //如果已经存在，直接返回
        if(find.getVal() != -1) {
            return;
        }

        //不存在，需要进行插入
        Node cur = find.getKey();
        //插入是在叶子结点进行的，不需要调整孩子结点
        int i = cur.usedSize - 1;
        for (; i >= 0; i--) {
            if(cur.keys[i] > key) {
                cur.keys[i+1] = cur.keys[i];
            } else {
                break;
            }
        }
        cur.keys[i+1] = key;
        cur.usedSize++;

        //是否需要进行分裂
        if(cur.usedSize == M) {
            split(cur);
        }
    }

    private void split(Node cur) {
        Node newNode = new Node();
        Node parent = cur.parent;

        //进行keys和孩子结点的拷贝
        int mid = M / 2;
        int i = 0;
        int j = mid + 1;
        for(; j < cur.usedSize; j++) {
            newNode.keys[i] = cur.keys[j];
            newNode.subs[i] = cur.subs[j];
            //如果拷贝过来的孩子结点不为空，需要修改孩子结点的双亲结点
            if(newNode.subs[i] != null) {
                newNode.subs[i].parent = newNode;
            }
            //usedSize 随之修改
            newNode.usedSize++;
            i++;
        }

        //还差一个孩子结点没有拷贝，再次拷贝孩子结点
        newNode.subs[i] = cur.subs[j];
        if(newNode.subs[i] != null) {
            newNode.subs[i].parent = newNode;
        }

        //新结点的双亲结点设置为 parent
        newNode.parent = parent;

        //设置 cur 的 usedSize 数值
        cur.usedSize = mid;

        //需要提取的中间关键字
        int midVal = cur.keys[mid];

        //特殊情况：当分裂的结点正好是根结点
        if(cur == root) {
            root = new Node();
            root.keys[0] = midVal;
            root.subs[0] = cur;
            root.subs[1] = newNode;
            cur.parent = newNode.parent = root;
            root.usedSize = 1;
            return;
        }

        //处理 parent 结点
        //将 cur 的中间关键值提到 parent;
        int end = parent.usedSize - 1;
        for(; end >= 0; end--) {
            if(parent.keys[end] > midVal) {
                parent.keys[end+1] = parent.keys[end];
                parent.subs[end+2] = parent.subs[end+1];
            } else {
                break;
            }
        }
        parent.keys[end+1] = midVal;
        parent.subs[end+2] = newNode;
        parent.usedSize++;

        //是否需要继续分裂
        if(parent.usedSize == M) {
            split(parent);
        }
    }

    //查找
    public Pair<Node,Integer> find(int key) {
        Node cur = root;
        Node prev = null;
        while(cur != null) {
            int i = 0;
            while(i < cur.usedSize) {
                if(cur.keys[i] == key) {
                    //存在该节点
                    return new Pair<>(cur,i);
                } else if(cur.keys[i] > key) {
                    //需要进入孩子结点继续查找
                    break;
                } else {
                    //继续查找
                    i++;
                }
            }
            prev = cur;
            cur = cur.subs[i];
        }

        //找不到，返回双亲结点
        return new Pair<>(prev,-1);
    }

    public void inorder(Node root){
        if(root == null)
            return;
        for(int i = 0; i < root.usedSize; ++i){
            inorder(root.subs[i]);
            System.out.println(root.keys[i]);
        }
        inorder(root.subs[root.usedSize]);
    }
}

B+树介绍

B+树是B-树的变形，也是一种多路搜索树：
其定义基本与B-树相同，除了：

  1. 非叶子节点的子树指针与关键字个数相同
  2. 非叶子节点的子树指针p[i]，指向关键字值属于【k[i]，k[i+1]】的子树【这句话的意思是B+树在B树的基础上只存在右子树，也就是说keys 数组第一个区域是不存在左孩子的，然后每一个孩子结点的范围是 k[i] 到 k[i+1] 之间的】
  3. 所有叶子节点通过双向链表进行连接
  4. 所有关键字都在叶子节点出现在这里插入图片描述

B+树的应用：
在MySQL中使用B+树来对数据进行管理，在下一篇MySQL的索引中我会进行详细的讲解。

B* 树介绍

B*树是B+树的变形，在B+树的非根和非叶子节点再增加指向兄弟节点的指针。
在这里插入图片描述
这样做的好处是可以节约存储空间，结点在进行分裂的时候，会优先先看看兄弟结点是否已满，如果没有满，会将数值插入到兄弟结点上。

熵减玩家
关注
专栏目录
JavaDS —— 红黑树
熵减玩家
08-06 1639
介绍红黑树的概念，性质，插入代码的实现已经性能分析
JavaDS —— AVL树
熵减玩家
08-04 1474
用Java 实现 AVL 树的插入与旋转
JavaDS —— 二叉树
熵减玩家
07-18 1175
JavaDS —— 二叉树
JavaDS —— 排序
熵减玩家
07-24 1536
Java 语言实现 七大排序算法加 计数排序
JavaDS —— 并查集
熵减玩家
09-08 1153
并查集介绍，使用Java 语言描述
JavaDS —— 顺序表ArrayList
熵减玩家
07-08 1449
Java中的ArrayList
JavaDS —— 单链表 与 LinkedList
熵减玩家
07-10 1372
JavaDS 链表
JavaDS —— 二叉搜索树、哈希表、Map 与 Set
熵减玩家
07-28 1165
模拟实现二叉搜索树和哈希表，介绍 Map 与 Set 的使用，并分析 TreMap、TreeSet、HashMap 与 HashSet 的区别，最后分析了 HashMap 的部分源码
JAVADS——快速排序
qq_53223625的博客
03-22 145
快速排序具体是在序列中选择一个元素（如何选择没有规定），接下来通过"遍历的方式"，比较所选定的元素和区间内其他元素的大小关系。 快排： 1) 如果区间内的元素个数<=1,则不用做任何处理，因为天然有序 2）从区间中（这里的区间不代表整个数组，所以需要通过[from,to]来限定）中挑选一个pivot，挑选方式随意 3）遍历区间，将每个元素都和pivot进行比较，并且进行必要的位置移动，是的完成区间遍历之后，整个数组被分成三个小区间，【<= pivot】【pivot...
JavaDS:JavaDS_HomeWork_Author
03-17
JavaDS，全称为Java Data Store，是Java领域中用于数据存储和管理的一种技术。这个"JavaDS_HomeWork_Author"可能是指一个关于JavaDS的学习项目或者作业，由作者完成。由于提供的信息有限，我将从JavaDS的基本概念、...
Java语言-数据结构与算法视频教程 （第一部分）
07-03
____18.JavaDS_有序链表.mp4 |____17.JavaDS_用链表实现抽象数据类型.mp4 |____16.JavaDS_双端链表.mp4 |____15.JavaDS_单链表.mp4 |____14.JavaDS_解析算术表达式.mp4 |____13.JavaDS_优先级队列.mp4 |____12....
［JavaDS］快速排序法
weixin_42645168的博客
06-03 809
目录 1思想： 2特点： 3步骤： 4代码实现： 5问题及其优化： 5.1优化：------三数取中法 5.2优化二：直接插入排序 预备知识： Random的用法 java中存在两种Random函数： 1java.lang.Math.Random Random()函数能够返回带正号的double值，该值大于等于0.0且小于1.0，即取值范围是[0.0,1.0)的左闭右开区间...
浅谈为什么数据库要用B树
做一个道者
09-10 1301
记住，数据库的性能往往决定了整个系统的响应速度，下一次当你遇到查询慢的问题时，别忘了看看你的索引结构，说不定你就能找到那个让系统加速的小“钥匙”！举个例子，假设你在数据库里存了一堆商品的价格信息，如果你想查询100到500元之间的商品，B+树的设计可以让你从一个叶子节点开始，顺着链表快速找到符合条件的所有数据。这种结构的好处是，数据更集中，查找效率更高，特别是当你要进行范围查询时，比如“找出大于50且小于100的所有记录”，B+树能帮你更快完成任务。别担心，我会用最简单的方式，帮你把这个复杂的概念搞清楚。
MySQL索引优化与B+树【后端 14】
delepaste的博客
09-11 1229
在MySQL数据库中，索引是优化查询性能的关键技术之一。B+树作为一种广泛使用的索引结构，在MySQL的InnoDB存储引擎中扮演着核心角色。本文将详细介绍B+树的结构特点及其在MySQL索引优化中的应用。
B-树底层原理
Echo_HY的博客
09-11 462
B-树（B-Tree）是一种自平衡的树形数据结构，广泛应用于数据库和操作系统中。它的设计目标是减少搜索、顺序访问、插入和删除操作中比较次数和移动次数，特别适合于磁盘中数据的存储和检索。
21_动态规划与数据结构结合
刘炫320的博客
09-11 532
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
数据结构 Java DS——分享部分链表题目 (2)
cjejwe的博客
09-10 951
关于JAVA的链表,笔者已经写了两篇博客来介绍了,今天给笔者们带来第三篇,也是分享了一些笔者写过的,觉得挺好的题目,链接也已经挂上了,笔者们可以去看看。
【华为OD】2024D卷——生成哈夫曼树
最新发布
weixin_45653183的博客
09-12 1288
这是通过构建一种特殊的二叉树来实现的，其中每个字符都位于树的一个叶节点上，且该叶节点到根节点的路径上的边所代表的字符（在哈夫曼编码中通常使用0和1表示）共同构成了该字符的编码。·新节点作为这两个子节点的父节点，而原来的两个节点则成为新节点的左右子节点（通常约定左子节点频率小于等于右子节点）。2、不断从堆中取出两个最小的节点作为左右子树，构造一个新的父节点，其权值为两个节点权值之和，并将新节点插入堆中。·然后，算法反复地选择两个频率最小的节点，将它们合并为一个新的节点，新节点的频率是两个子节点频率之和。
评论 26
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值