B Plus Tree

已于 2023-02-27 21:40:25 修改
阅读量344 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 算法
于 2020-08-16 15:30:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhixingheyi_tian/article/details/108037042
版权

树的基本概念

结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
树的高度或深度：树中结点的最大层次；

B树：有序数组+平衡多叉树；数据存在于非叶子节点上

B+树：有序数组链表+平衡多叉树；数据只存在于叶子上。

B*树：一棵丰满的B+树。

B+树还有一个最大的好处，方便扫库，B树必须用中序遍历的方法按序扫库，而B+树直接从叶子结点挨个扫一遍就完了，B+树支持range-query非常方便，而B树不支持。这是数据库选用B+树的最主要原因。

描述一颗 B树时需要指定它的阶数，阶数 表示 此树的结点 最多 有 多少个孩子结点（子树），一般用字母 M 表示阶数。

M 阶的B树 ：以【子树】讨论

上限：每个节点最多有 M 个子树
下限：
根节点至少2个子树，
非根节点至少有⌈M /2⌉个子树
所以也称 M 阶B树 为 ( ⌈M /2⌉ , M ) 树 ，即超级节点（除根节点）的子树数的上下限 。

磁盘IO

IO读的次数取决于B+树的高度， H=3 ，IO一般只需三次。
读取的磁盘节点块，内部元素查找属于内存查找，可以使用折半查找（二分查找）

zhixingheyi_tian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
b_plus_tree:B+树在Java中的实现。 疯了吧
05-29
b_plus_tree B+树在Java中的实现。 疯了吧。
BPlusTree B+树算法程序
02-04
B+树的演示程序，在vs.net 2003 下编译通过。是数据库基础的课程设计。
B树、B-树、B+树、B*树详解
上善若水
03-10 891
B树        即二叉搜索树：        1.所有非叶子结点至多拥有两个儿子（Left和Right）；        2.所有结点存储一个关键字；        3.非叶子结点的左指针指向小于其关键字的子树，右指针指向大于其关键字的子树；        如：                B树的搜索，从根结点开始，如果查询的关键字与结点的关键字相等，那么就命中；否则，如果...
白话解析B+树并附Java完整实现
qq_36456827的博客
12-28 5158
白话解析B+树并附Java完整实现
BPlusTree(B+树)的一种实现---转
码农
02-19 1919
来自：http://hi.baidu.com/lovelink/item/fd60de0d1c4ca1cf905718aa 以下是C++源代码，拷贝保存为cpp文件即可编译。 该代码实现了B+树的索引文件，可以用于数据库中的稀疏索引和密集索引，具体请看注释。 由于水平所限，本人仅保证其能正常运行，不保证执行效率及合理性。 仅供参考，All Rights Reserved----------
b_plus_tree.zip_B plus tree_b tree plus_b+tree_b-tree_plus
09-23
b plus tree in windows c++
b_plus_tree.zip_b 树_b+tree_b_plus_tree_b树数据库_galles b plus tree
09-19
支持b+ tree树的初始化以及增删改操作，借以了解数据库中index的数据结构
b plus tree ppt
07-07
b plus tree ppt, how to delete and insert
基于BPlus Tree算法的模拟数据库
03-14
基于BPlus Tree算法的模拟数据库，还实现了关键字加密存储！
b_plus_tree.rar_b+tree_b+tree磁盘_b+树 文件_plus_磁盘实现B+树
09-19
b+树的实现和测试，模拟磁盘文件工作。一门课程的project。
bplustree：数十亿键值存储的最小但极其快速的B +树索引结构演示
02-04
B +树 基于Posix的数百万（数十亿）键值存储的最小B + Tree实现。 科 用于学习和调试。 演示版 ./demo_build.sh 代码覆盖率测试 注意：此测试需要首先使用rm /tmp/coverage.index* ！ ./coverage_build.sh
BPlusTree_Java实现
11-12
BPlusTree_Java实现 package bplustree; import java.util.*; import com.xuedi.IO.*; import com.xuedi.maths.*; ////// DisposeRoot ///////中的key参数有些问题 public class BTree { //用于记录每个节点中的键值数量 public int keyAmount; //树的根节点 public Node root; public BTree(int keyAmount) { this.keyAmount = keyAmount; this.root = new Node(keyAmount); } //在B树中插入叶节点///////////////////////////////////////////////////////////// public void insert(long key,Object pointer) { //找到应该插入的节点 Node theNode = search(key,root); //在叶节点中找到空闲空间，有的话就把键放在那里 if( !isFull(theNode) ) { putKeyToNode(key,pointer,theNode); }else{ //如果在适当的叶节点没有空间，就把该叶节点分裂成两个，并正确分配键值 Node newNode = separateLeaf(key,pointer,theNode); //如果分裂的是根节点，就新建一个新的根节点将新建的节点作为他的字节点 if( isRoot(theNode) ) { DisposeRoot(theNode,newNode,newNode.keys[0]); }else{ //将新建立的节点的指针插入到上层节点 insertToInnerNode(theNode.parent,newNode,newNode.keys[0]); } } } //lowerNode是下级节点分离后新建立的那个节点/////////////////////////////////////// //upperNode是lowerNode的上层节点 private void insertToInnerNode(Node upperNode,Node lowerNode,long key) { //上层节点有空位就直接插入 if( !isFull(upperNode) ) { putKeyToNode(key,lowerNode,upperNode); //重置父节点指针 pointerRedirect(upperNode); return; }else{ //如果分裂的是根节点，就新建一个新的根节点将新建的节点作为他的子节点 Node newNode; if( isRoot(upperNode) ) { newNode = separateInnerNode(key,lowerNode,upperNode); Node newRoot = new Node(this.keyAmount); newRoot.pointer[0] = upperNode; newRoot.pointer[1] = newNode; upperNode.parent = newRoot; newNode.parent = newRoot; newRoot.keyAmount = 1; newRoot.keys[0] = key; root = newRoot; //重置父节点指针 pointerRedirect(upperNode); return; }else{ //上层非根节点没有空位进行分裂和插入操作 newNode = separateInnerNode(key,lowerNode,upperNode); //重置父节点指针 pointerRedirect(upperNode); //记录要向上插入的键值在源节点中的位置(该键值在separateInnerNode()被保留在srcNode中) int keyToUpperNodePosition = upperNode.keyAmount; //向上递归插入 insertToInnerNode(upperNode.parent,newNode,upperNode.keys[keyToUpperNodePosition]); //重置父节点指针 pointerRedirect(newNode); } } } //将对应的内部节点进行分裂并正确分配键值，返回新建的节点 private Node separateInnerNode(long key,Object pointer,Node srcNode) { Node newNode = new Node(this.keyAmount); //因为我在Node中预制了一个位置用于插入，而下面的函数(putKeyToLeaf())不进行越界检查 //所以可以将键-指针对先插入到元节点，然后再分别放到两个节点中 putKeyToNode(key,pointer,srcNode); //先前节点后来因该有(n+1)/2取上界个键－值针对 int ptrSaveAmount = (int)com.xuedi.maths.NumericalBound.getBound(0,(double)(this.keyAmount+1)/2); int keySaveAmount = (int)com.xuedi.maths.NumericalBound.getBound(0,(double)(this.keyAmount)/2); int keyMoveAmount = (int)com.xuedi.maths.NumericalBound.getBound(1,(double)(this.keyAmount)/2); //(n+1)/2取上界个指针和n/2取上界个键留在源节点中 //剩下的n+1)/2取下界个指n/2取下界个键留在源节点中 for (int k = ptrSaveAmount; k < srcNode.keyAmount; k++) { newNode.add(srcNode.keys[k], srcNode.pointer[k]); } newNode.pointer[newNode.keyAmount] = srcNode.pointer[srcNode.pointer.length-1]; srcNode.keyAmount = keySaveAmount; return newNode; } //将对应的叶节点进行分裂并正确分配键值，返回新建的节点/////////////////////////////// private Node separateLeaf(long key,Object pointer,Node srcNode) { Node newNode = new Node(this.keyAmount); //兄弟间的指针传递 newNode.pointer[this.keyAmount] = srcNode.pointer[this.keyAmount]; //因为我在Node中预制了一个位置用于插入，而下面的函数(putKeyToLeaf())不进行越界检查 //所以可以将键-指针对先插入到元节点，然后再分别放到两个节点中 putKeyToNode(key,pointer,srcNode); //先前节点后来因该有(n+1)/2取上界个键－值针对 int oldNodeSize = (int)com.xuedi.maths.NumericalBound.getBound(0,(double)(this.keyAmount+1)/2); for(int k = oldNodeSize; k <= this.keyAmount; k++) { newNode.add(srcNode.keys[k],srcNode.pointer[k]); } srcNode.keyAmount = oldNodeSize; //更改指针--让新节点成为就节点的右边的兄弟 srcNode.pointer[this.keyAmount] = newNode; return newNode; } //把键值放到叶节点中--这个函数不进行越界检查//////////////////////////////////////// private void putKeyToNode(long key,Object pointer,Node theNode) { int position = getInsertPosition(key,theNode); //进行搬迁动作--------叶节点的搬迁 if( isLeaf(theNode) ) { if(theNode.keyAmount <= position) { theNode.add(key,pointer); return; } else{ for (int j = theNode.keyAmount - 1; j >= position; j--) { theNode.keys[j + 1] = theNode.keys[j]; theNode.pointer[j + 1] = theNode.pointer[j]; } theNode.keys[position] = key; theNode.pointer[position] = pointer; } }else{ //内部节点的搬迁----有一定的插入策略： //指针的插入比数据的插入多出一位 for (int j = theNode.keyAmount - 1; j >= position; j--) { theNode.keys[j + 1] = theNode.keys[j]; theNode.pointer[j + 2] = theNode.pointer[j+1]; } theNode.keys[position] = key; theNode.pointer[position+1] = pointer; } //键值数量加1 theNode.keyAmount++; } //获得正确的插入位置 private int getInsertPosition(long key,Node node) { //将数据插入到相应的位置 int position = 0; for (int i = 0; i < node.keyAmount; i++) { if (node.keys[i] > key) break; position++; } return position; } //有用的辅助函数//////////////////////////////////////////////////////////////// //判断某个结点是否已经装满了 private boolean isFull(Node node) { if(node.keyAmount >= this.keyAmount) return true; else return false; } //判断某个节点是否是叶子结点 private boolean isLeaf(Node node) { //int i = 0; if(node.keyAmount == 0) return true; //如果向下的指针是Node型，则肯定不是叶子节点 if(node.pointer[0] instanceof Node) return false; return true; } private boolean isRoot(Node node) { if( node.equals(this.root) ) return true; return false; } //给内部节点中的自己点重新定向自己的父亲 private void pointerRedirect(Node node) { for(int i = 0; i <= node.keyAmount; i++) { ((Node)node.pointer[i]).parent = node; } } //新建一个新的根节点将新建的节点作为他的字节点 private void DisposeRoot(Node child1,Node child2,long key) { Node newRoot = new Node(this.keyAmount); newRoot.pointer[0] = child1; newRoot.pointer[1] = child2; newRoot.keyAmount = 1; newRoot.keys[0] = key; root = newRoot; //如果两个孩子是叶节点就让他们两个相连接 if( isLeaf(child1) ) { //兄弟间的指针传递 child2.pointer[this.keyAmount] = child1.pointer[this.keyAmount]; child1.pointer[this.keyAmount] = child2; } pointerRedirect(root); return; } /////////////////////////////////////////////////////////////////////////////// //用于寻找键值key所在的或key应该插入的节点 //key为键值,curNode为当前节点--一般从root节点开始 public Node search(long key,Node curNode) { if (isLeaf(curNode)) return curNode; for (int i = 0; i < this.keyAmount; i++) { if (key < curNode.keys[i]) //判断是否是第一个值 return search(key, (Node) curNode.pointer[i]); else if (key >= curNode.keys[i]) { if (i == curNode.keyAmount - 1) //如果后面没有值 { //如果key比最后一个键值大,则给出最后一个指针进行递归查询 return search(key,(Node) curNode.pointer[curNode.keyAmount]); } else { if (key < curNode.keys[i + 1]) return search(key, (Node) curNode.pointer[i + 1]); } } } //永远也不会到达这里 return null; } }
BPlusTree:Java - 使用 B+ 树的大数据存储
07-13
BPlus树 Java - 使用 B+ 树的大数据存储
BTree-and-BPlusTree-Realize:BTree和BPlusTree实现
05-11
文件说明： 1.Tree.h：B树和B+树的通用接口，虚基类。BTree和BPlusTree都继承它，只有BPlusTree才有linear函数 2.BTree.h,BTree.cpp：B树的声明、实现代码 3.BPlusTree.h,BPlusTree.cpp：B+树的声明、实现代码，注：大多数的函数，B和B+都是一样的，但是我还是分开写了，比如输出函数 4.Context.h：策略方法的实现 5.mian.cpp：使用用例,因为我测试的时候windows和linux都有，为使中文不乱码，我在main写的简单的英语说明 不足之处的改进 对于数据库来说，目前的BTree操作有两个大问题，一个是吃内存（我是把整体数据在内存中操作），另一个是没能立即持久化。而数据库的其他功能，如事务处理、并发暂不考虑。 针对以上提到的2个问题（吃内存，没持久化），实现方案思路如下： 1.只是把B+树的部份放在
BPlusTree
07-30
NULL 博文链接：https://boyfuxin.iteye.com/blog/841254
B+tree详解及实现(C语言)
热门推荐
Coding365
08-11 2万+
1 什么是B+tree 如果你还不了解B-tree，那么请自行了解。可以参考我的这篇帖子---B-tree详解及实现。 B+tree是B-tree的一个变种：在B-tree的基础上，为叶子节点增加链表指针，而且所有的关键字都在叶子节点中出现，且数据只存储在叶子节点中。非叶子节点的关键字仅作为叶子节点的索引。下图是一棵B+tree。 B+tree 的插入和删除基本和B-tree一样，只是多了数据结构多了next字段，所以要注意。
B+tree 实现
明天会更好
03-08 434
转自：http://blog.csdn.net/hpghy123456/article/details/7719052 /**   BPlusTree.h         2012/6/24--2012/7/5   hpghy, [email protected]      **/      #ifndef BPLUSTREE_H_   #define BPLUSTR
B+ tree的java实现
TVXQ_xy的博客
11-02 3673
这个代码来自网址：http://bofang.iteye.com/blog/1387785 挺好用的，感谢！import java.util.HashMap; import java.util.Map; /** * The simple implementation of B+-Tree, reference http://en.wikipedia.org/wiki/B%2B_tree *
B Tree B plus Tree and B star Tree
fanjingdan的专栏
06-24 234
Index Hash linear index(memory or disk)就是一串key/pointer,key是顺序排列的，pointer指向具体记录 tree B tree 多路搜索树，比如2-3 tree 2-3-4 tree=红黑树 CRUD都在那边讲过了，这里贴个图方便对比 为了做index的性质 balanced：所有叶子都是一层的 一般一个node的大小就是一个page...
修改jqgrid tree 图标为文件图片
最新发布
06-07
"plus": "ui-icon-document", "minus": "ui-icon-document-b", "leaf": "ui-icon-document" }, ExpandColumn: "name", ExpandColClick: true, height: "auto", pager: false, caption: "Tree Grid" }); ```...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值