数据结构-B树，B+树

转载https://blog.csdn.net/whoamiyang/article/details/51926985

B/B+树

注意B-树就是B树,-只是一个符号.

简介

B/B+树是为了磁盘或其它存储设备而设计的一种平衡多路查找树(相对于二叉,B树每个内节点有多个分支),与红黑树相比,在相同的的节点的情况下,一颗B/B+树的高度远远小于红黑树的高度(在下面B/B+树的性能分析中会提到).B/B+树上操作的时间通常由存取磁盘的时间和CPU计算时间这两部分构成,而CPU的速度非常快,所以B树的操作效率取决于访问磁盘的次数,关键字总数相同的情况下B树的高度越小，磁盘I/O所花的时间越少.

B树的性质

  • 定义任意非叶子结点最多只有M个儿子；且M>2；
  • 根结点的儿子数为[2, M]；
  • 除根结点以外的非叶子结点的儿子数为[M/2, M]；
  • 每个结点存放至少M/2-1（取上整）和至多M-1个关键字；（至少2个关键字）
  • 非叶子结点的关键字个数=指向儿子的指针个数-1；
  • 非叶子结点的关键字：K[1], K[2], …, K[M-1]；且K[i] < K[i+1]；
  • 非叶子结点的指针：P[1], P[2], …, P[M]；其中P[1]指向关键字小于K[1]的子树，P[M]指向关键字大于K[M-1]的子树，其它P[i]指向关键字属于(K[i-1], K[i])的子树；
  • 所有叶子结点位于同一层； 
    数据结构-B树，B+树
    这里只是一个简单的B树,在实际中B树节点中关键字很多的.上面的图中比如35节点,35代表一个key(索引)，而小黑块代表的是这个key所指向的内容在内存中实际的存储位置.是一个指针.
  • 数据结构-B树，B+树
  • 数据结构-B树，B+树

  • B-树的插入

    其实B-树的插入是很简单的，它主要是分为如下的两个步骤：

  • 1. 使用之前介绍的查找算法查找出关键字的插入位置，如果我们在B-树中查找到了关键字，则直接返回。否则它一定会失败在某个最底层的终端结点上。

  • 2.然后，我就需要判断那个终端结点上的关键字数量是否满足：n<=m-1,如果满足的话，就直接在该终端结点上添加一个关键字，否则我们就需要产生结点的“分裂”。

  • 分裂的方法是：生成一新结点。把原结点上的关键字和k（需要插入的值）按升序排序后，从中间位置把关键字（不包括中间位置的关键字）分成两部分。左部分所含关键字放在旧结点中，右部分所含关键字放在新结点中，中间位置的关键字连同新结点的存储位置插入到父结点中。如果父结点的关键字个数也超过（m-1），则要再分裂，再往上插。直至这个过程传到根结点为止。

  • 1
  • 2
  • 3
  • 4

  • 下面我们来举例说明，首先假设这个B-树的阶为：3。树的初始化时如下： 
    数据结构-B树，B+树

    首先，我需要插入一个关键字：30，可以得到如下的结果： 
    数据结构-B树，B+树

    再插入26，得到如下的结果：

    数据结构-B树，B+树

    OK，此时如图所示，在插入的那个终端结点中，它的关键字数已经超过了m-1=2，所以我们需要对结点进分裂，所以我们先对关键字排序，得到：26 30 37 ，所以它的左部分为（不包括中间值）：26，中间值为：30，右部为：37，左部放在原来的结点，右部放入新的结点，而中间值则插入到父结点，并且父结点会产生一个新的指针，指向新的结点的位置，如下图所示： 
    数据结构-B树，B+树

    OK，然后我们继续插入新的关键字：85，得到如下图结果： 
    数据结构-B树，B+树

    正如图所示，我需要对刚才插入的那个结点进行“分裂”操作，操作方式和之前的一样，得到的结果如下： 
    数据结构-B树，B+树

    哦，当我们分裂完后，突然发现之前的那个结点的父亲结点的度为4了，说明它的关键字数超过了m-1，所以需要对其父结点进行“分裂”操作，得到如下的结果： 
    数据结构-B树，B+树

    好，我们继续插入一个新的关键字：7，得到如下结果： 
    数据结构-B树，B+树

    同样，需要对新的结点进行分裂操作，得到如下的结果： 
    数据结构-B树，B+树
    到了这里，我就需要继续对我们的父亲结点进行分裂操作，因为它的关键字数超过了：m-1. 
    数据结构-B树，B+树

    哦，终于遇到这种情况了，我们的根结点出现了关键子数量超过m-1的情况了，这个时候我们需要对父亲结点进行分列操作，但是根结点没父亲啊，所以我们需要重新创建根结点了。 
    数据结构-B树，B+树

    好了，到了这里我们也知道怎么进行B-树的插入操作。

    B-树的删除操作

    B-树的删除操作同样是分为两个步骤：

  • 利用前述的B-树的查找算法找出该关键字所在的结点。然后根据 k（需要删除的关键字）所在结点是否为叶子结点有不同的处理方法。如果没有找到，则直接返回。
  • 若该结点为非叶结点，且被删关键字为该结点中第i个关键字key[i]，则可从指针son[i]所指的子树中找出最小关键字Y，代替key[i]的位置，然后在叶结点中删去Y。

  • 如果是叶子结点的话，需要分为下面三种情况进行删除。

  • 如果被删关键字所在结点的原关键字个数n>=[m/2] ( 上取整），说明删去该关键字后该结点仍满足B-树的定义。这种情况最为简单，只需删除对应的关键字：k和指针：A 即可。
  • 如果被删关键字所在结点的关键字个数n等于( 上取整）[ m/2 ]-1，说明删去该关键字后该结点将不满足B-树的定义，需要调整。

  • 调整过程为：如果其左右兄弟结点中有“多余”的关键字,即与该结点相邻的右兄弟(或左兄弟)结点中的关键字数目大于( 上取整）[m/2]-1。则可将右兄弟(或左兄弟)结点中最小关键字(或最大的关键字)上移至双亲结点。而将双亲结点中小（大）于该上移关键字的关键字下移至被删关键字所在结点中。

  • 被删关键字所在结点和其相邻的兄弟结点中的关键字数目均等于（上取整）[m/2]-1。假设该结点有右兄弟，且其右兄弟结点地址由双亲结点中的指针Ai所指，则在删去关键字之后，它所在结点中剩余的关键字和指针，加上双亲结点中的关键字Ki一起，合并到 Ai所指兄弟结点中(若没有右兄弟，则合并至左兄弟结点中)。

  • 下面，我们给出删除叶子结点的三种情况： 
    第一种：关键字的数不小于（上取整）[m/2]，如下图删除关键字：12 
    数据结构-B树，B+树 
    删除12后的结果如下，只是简单的删除关键字12和其对应的指针。 
    数据结构-B树，B+树

    第二种：关键字个数n等于( 上取整）[ m/2 ]-1，而且该结点相邻的右兄弟(或左兄弟)结点中的关键字数目大于( 上取整）[m/2]-1。 
    数据结构-B树，B+树

    如上图，所示，我们需要删除50这个关键字，所以我们需要把50的右兄弟中最小的关键字：61上移到其父结点，然后替换小于61的关键字53的位置，53则放至50的结点中。然后，我们可以得到如下的结果： 
    数据结构-B树，B+树

    第三种：关键字个数n等于( 上取整）[ m/2 ]-1，而且被删关键字所在结点和其相邻的兄弟结点中的关键字数目均等于（上取整）[m/2]-1

    数据结构-B树，B+树

    如上图所示，我们需要删除53，那么我们就要把53所在的结点其他关键字（这里没有其他关键字了）和父亲结点的61这个关键字一起合并到70这个关键字所占的结点。得到如下所示的结果： 
    数据结构-B树，B+树

B+树

B+树是应文件系统所需而产生的一种B树的变形树(文件的目录一级一级索引,只有最底层的叶子节点(文件)保存数据.),非叶子节点只保存索引,不保存实际的数据,数据都保存在叶子节点中.这不就是文件系统文件的查找吗?我们就举个文件查找的例子:有3个文件夹,a,b,c, a包含b,b包含c,一个文件yang.c, a,b,c就是索引(存储在非叶子节点), a,b,c只是要找到的yang.c的key,而实际的数据yang.c存储在叶子节点上. 
所有的非叶子节点都可以看成索引部分

B+树的性质(下面提到的都是和B树不相同的性质)

  • 非叶子节点的子树指针与关键字个数相同;
  • 非叶子节点的子树指针p[i],指向关键字值属于[k[i],k[i+1]]的子树.(B树是开区间,也就是说B树不允许关键字重复,B+树允许重复)；
  • 为所有叶子节点增加一个链指针.
  • 所有关键字都在叶子节点出现(稠密索引). (且链表中的关键字恰好是有序的);
  • 非叶子节点相当于是叶子节点的索引(稀疏索引),叶子节点相当于是存储(关键字)数据的数据层.
  • 更适合于文件系统; 
    看下图: 
    数据结构-B树，B+树
    非叶子节点(比如5,28,65)只是一个key(索引),实际的数据存在叶子节点上(5,8,9)才是真正的数据或指向真实数据的指针.
  • 数据结构-B树，B+树

应用　　

B和B+树主要用在文件系统以及数据库做索引.比如Mysql;

B/B+树性能分析　

  • n个节点的平衡二叉树的高度为H(即logn),而n个节点的B/B+树的高度为logt((n+1)/2)+1; 　　
  • 若要作为内存中的查找表,B树却不一定比平衡二叉树好,尤其当m较大时更是如此.因为查找操作CPU的时间在B-树上是O(mlogtn)=O(lgn(m/lgt)),而m/lgt>1;所以m较大时O(mlogtn)比平衡二叉树的操作时间大得多. 因此在内存中使用B树必须取较小的m.（通常取最小值m=3，此时B-树中每个内部结点可以有2或3个孩子，这种3阶的B-树称为2-3树）。

为什么说B+tree比B树更适合实际应用中操作系统的文件索引和数据索引.　　

  • B+-tree的内部节点并没有指向关键字具体信息的指针,因此其内部节点相对B树更小,如果把所有同一内部节点的关键字存放在同一盘块中,那么盘块所能容纳的关键字数量也越多,一次性读入内存的需要查找的关键字也就越多,相对IO读写次数就降低了.
  • 由于非终结点并不是最终指向文件内容的结点，而只是叶子结点中关键字的索引。所以任何关键字的查找必须走一条从根结点到叶子结点的路。所有关键字查询的路径长度相同，导致每一个数据的查询效率相当。 
     数据库索引采用B+树的主要原因是:B树在提高了IO性能的同时并没有解决元素遍历的我效率低下的问题,正是为了解决这个问题,B+树应用而生.B+树只需要去遍历叶子节点就可以实现整棵树的遍历.而且在数据库中基于范围的查询是非常频繁的，而B树不支持这样的操作（或者说效率太低）.　    　
  • 参考文章：https://blog.csdn.net/whoamiyang/article/details/51926985

  • B*树

           是B+树的变体，在B+树的非根和非叶子结点再增加指向兄弟的指针；

    数据结构-B树，B+树

       B*树定义了非叶子结点关键字个数至少为(2/3)*M，即块的最低使用率为2/3

    （代替B+树的1/2）；

           B+树的分裂：当一个结点满时，分配一个新的结点，并将原结点中1/2的数据

    复制到新结点，最后在父结点中增加新结点的指针；B+树的分裂只影响原结点和父

    结点，而不会影响兄弟结点，所以它不需要指向兄弟的指针；

           B*树的分裂：当一个结点满时，如果它的下一个兄弟结点未满，那么将一部分

    数据移到兄弟结点中，再在原结点插入关键字，最后修改父结点中兄弟结点的关键字

    （因为兄弟结点的关键字范围改变了）；如果兄弟也满了，则在原结点与兄弟结点之

    间增加新结点，并各复制1/3的数据到新结点，最后在父结点增加新结点的指针；

           所以，B*树分配新结点的概率比B+树要低，空间使用率更高；

      

    小结

  •        B-树：多路搜索树，每个结点存储M/2到M个关键字，非叶子结点存储指向关键

    字范围的子结点；

           所有关键字在整颗树中出现，且只出现一次，非叶子结点可以命中；

           B+树：在B-树基础上，为叶子结点增加链表指针，所有关键字都在叶子结点

    中出现，非叶子结点作为叶子结点的索引；B+树总是到叶子结点才命中；

           B*树：在B+树基础上，为非叶子结点也增加链表指针，将结点的最低利用率

    从1/2提高到2/3；

  • 参考：https://blog.csdn.net/zwz2011303359/article/details/63262541

相关文章：

  • 2021-09-16
  • 2021-06-01
  • 2021-12-28
  • 2021-11-12
  • 2021-09-27
  • 2021-07-09
  • 2022-01-15
  • 2021-09-08
猜你喜欢
  • 2021-09-21
  • 2021-09-23
  • 2021-12-05
  • 2021-05-09
  • 2021-04-13
  • 2022-01-13
  • 2021-07-12
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode