B-树（插入删除）代码+逻辑

1.出现缘由

当数据量很大时，内存不够，找磁盘。为了提高取数据的速度，减少树的高度->多叉

2.特点

每个结点包含多个关键字，包含上界和下界。最小度数(取决于磁盘块)做衡量t>=2
所有的叶子结点都在同一层，并且不带信息 (可以看做是外部结点或查找失败的结点，实际上这些结点不存在，指向这些结点的指针为空)
对于一个有x个关键字的结点，它有x+1个孩子
每个结点中的关键字升序
根结点至少包含一个关键字，但是上界是一样的

3.插入

主动插入，往叶子结点插

在插入寻找的过程中，只要碰到满结点都做拆分，不管他是不是目标结点

4.删除

4.1如果待删除的结点在结点x中且x是叶子结点直接删除

4.2如果待删除的结点在结点x中且x是内部结点。

4.2.1如果位于x中某个关键字前一个孩子y至少有t个关键字

删除关键字G，其前一个孩子为DEF，关键字G的直接前驱为F，删除F，然后将G替换为F

4.2.2如果位于x中某个关键字前一个孩子y少于t个关键字，后一个孩子不少于t个关键字

删除关键字C，其前一个孩子为AB，小于t=3，后一个孩子DEF不小于3，关键字C的直接后继为D，删除D，然后将C替换为D

4.2.3如果位于x中某个关键字前、后孩子都少于t个关键字

删除关键字C，前一个孩子为AB，后一个孩子为DE（此处假设F已经被删掉了），均小于t=3，合并关键字C和结点DE到结点AB中，此时C在叶子结点中，直接删除

4.3如果打破了b树规则（删除是递归过程，删除和调整是一体的）

4.3.1如果子树和他相邻的兄弟都只有t-1，子树和兄弟合并，父结点一个关键字下移

4.3.2如果只有子树是t-1相邻的兄弟至少t个，则将x的一个关键字下移到子树中，将相邻的兄弟中的一个关键字上移到x中，相应的孩子指针也上移，使得x新增加一个关键字（直接返回不需要递归）

package Tree.bTree;import java.util.LinkedList;public class BTreeNode {//b树的阶int M;//关键字列表LinkedList<Integer> values;//父结点BTreeNode parent;//孩子列表LinkedList<BTreeNode> children;//构造构造一棵空的B-树private BTreeNode(){this.values = new LinkedList<Integer>();this.children = new LinkedList<BTreeNode>();}//构造一棵空的m阶B-树public BTreeNode(int m){this();if(m<3){throw new RuntimeException("阶数大于2");}this.M = m;}//根据父结点构造一个空的孩子结点public BTreeNode(BTreeNode parent){this(parent.M);this.parent = parent;}/*** 获取根结点* @return 根结点*/public BTreeNode getRoot(){BTreeNode p = this;while(!p.isRoot()){p = p.parent;}return p;}/*** 判断当前结点是不是根结点* @return 是就返回真*/public boolean isRoot(){return parent == null;}/*** 判断当前结点是不是空结点* @return 是就真*/public boolean isEmpty(){if(values == null||values.size()==0){return true;}return false;}/*** 清空当前结点，保留父关系*/public void clear(){values.clear();children.clear();}/*** 从当前结点往下查找目标值target* @param target 目标值* @return 找到返回找到的结点，没有就返回null的叶子结点*/public BTreeNode search(int target){if(isEmpty()){return this;}int valueIndex = 0;while(valueIndex < values.size()&&values.get(valueIndex)<=target){if(values.get(valueIndex) == target){return this;}valueIndex++;}return children.get(valueIndex).search(target);}/***插入结点，先找到根结点，从根结点往下找到插入的位置，如果是重复的数据就抛出异常* 插入可能会产生新的根结点，返回新的结点* @param e 插入的关键字* @return 新的根结点*/public BTreeNode insert(int e){if(isEmpty()){values.add(e);children.add(new BTreeNode(this));children.add(new BTreeNode(this));return this;}BTreeNode p = getRoot().search(e);if(!p.isEmpty()){throw new RuntimeException("cannot insert duplicate key to B-Tree, key: " + e);}insertNode(p.parent,e,new BTreeNode(p.M));return getRoot();}/*** 向指定结点内插入关键字和关键字右侧的孩子结点，如果没有大于2m-1，就找到结点内部的插入位置，然后直接插入* 一定是叶子插入* @param node 插入的结点* @param e 待插入的关键字* @param eNode 待插入的关键字右侧的孩子结点*/private void insertNode(BTreeNode node,int e,BTreeNode eNode){int valueIndex = 0;while(valueIndex < node.values.size()&&node.values.get(valueIndex)<e){valueIndex++;}node.values.add(valueIndex,e);eNode.parent = node;node.children.add(valueIndex+1,eNode);//这里的M阶相当于2m-1if(node.values.size()>M-1){int upIndex = M/2;int up = node.values.get(upIndex);//当前结点分为左右两部分，左边的parent不变，新建右边结点瓜分原来的右半边BTreeNode rNode = new BTreeNode(M);rNode.values = new LinkedList<>(node.values.subList(upIndex+1,M));rNode.children = new LinkedList<>(node.children.subList(upIndex+1,M+1));for (BTreeNode rChild : rNode.children){rChild.parent = rNode;}node.values = new LinkedList<>(node.values.subList(0,upIndex));node.children = new LinkedList<>(node.children.subList(0,upIndex+1));//从根结点上升,选取上升关键字作为新的根结点if(node.parent == null){node.parent = new BTreeNode(M);node.parent.values.add(up);node.parent.children.add(node);node.parent.children.add(rNode);rNode.parent = node.parent;return;}//父结点增加关键字，递归调用insertNode(node.parent,up,rNode);}}/*** 以当前节点为根，在控制台打印B-树*/public void print() {printNode(this, 0);}/*** 控制台打印节点的递归调用** @param node 要打印节点* @param depth 递归深度*/private void printNode(BTreeNode node, int depth) {StringBuilder sb = new StringBuilder();for(int i = 1; i < depth; i++) {sb.append("|    ");}if(depth > 0) {sb.append("|----");}sb.append(node.values);System.out.println(sb.toString());for(BTreeNode child : node.children) {printNode(child, depth+1);}}public BTreeNode delete(int e){if(isEmpty()){return this;}BTreeNode p = getRoot().search(e);if(p.isEmpty()) {throw new RuntimeException("the key to be deleted is not exist, key: " + e);}//找到目标结点的位置int valueIndex = 0;while(valueIndex < p.values.size() && p.values.get(valueIndex) < e){valueIndex++;}//不是最下层结点中的关键字if(!p.children.get(0).isEmpty()){BTreeNode rMin = p.children.get(valueIndex);while(!rMin.children.get(0).isEmpty()){//一直找到叶子结点rMin = rMin.children.get(0);}//用最小的最大关键字替换p.values.set(valueIndex,rMin.values.get(0));//删除了最下层结点有可能导致关键字数小于t-1//rMin是最下层结点，valueIndex是原结点的位置return delete(rMin,valueIndex,0);}return delete(p,valueIndex,0);}/*** 删除指定结点中的关键字和孩子，并处理删除后打破b-树规则的情况* @param target 目标结点* @param valueIndex 关键字索引* @param childIndex 孩子索引* @return 删除完成后的根结点*/private BTreeNode delete(BTreeNode target,int valueIndex,int childIndex){target.values.remove(valueIndex);target.children.remove(childIndex);//目标结点满足规则直接返回，不进行下一步调整if(target.children.size() >= Math.ceil(M/2.0)){return target.getRoot();}//根结点比较特殊if(target.isRoot()){//孩子数量满足要求if(target.children.size()>1){return target;} else{//只有一个孩子，直接上移，返回BTreeNode newRoot = target.children.get(0);newRoot.parent = null;return newRoot;}}//找到目标结点的位置int parentChildIndex = 0;while(parentChildIndex < target.parent.children.size() && target.parent.children.get(parentChildIndex) != target) {parentChildIndex++;}/*** 等于0表示没有左兄弟* 不满足b树结构要求，下面就是进行调整步骤*/if(parentChildIndex > 0 &&target.parent.children.get(parentChildIndex - 1).values.size() >= Math.ceil(M/2.0)){//左兄弟关键字数大于t-1int downKey = target.parent.values.get(parentChildIndex-1);BTreeNode leftSibling = target.parent.children.get(parentChildIndex-1);int upKey = leftSibling.values.remove(leftSibling.values.size()-1);//删除孩子用来替换的关键字BTreeNode mergeChild = leftSibling.children.remove(leftSibling.children.size()-1);//关键字下移target.values.add(0, downKey);//孩子指针也上移target.children.add(0, mergeChild);//替换target.parent.values.set(parentChildIndex-1, upKey);return target.getRoot();} else if(parentChildIndex < target.parent.children.size()-1 &&target.parent.children.get(parentChildIndex+1).values.size() >= Math.ceil(M/2.0)){// 右兄弟关键字数大于 ceil(M/2)-1，且有右孩子int downKey = target.parent.values.get(parentChildIndex);BTreeNode rightSibling = target.parent.children.get(parentChildIndex+1);int upKey = rightSibling.values.remove(0);BTreeNode mergeChild = rightSibling.children.remove(0);target.values.add(downKey);target.children.add(mergeChild);target.parent.values.set(parentChildIndex, upKey);return target.getRoot();} else{//左右兄弟关键字数都不大于t-1int parentValueIndex;if(parentChildIndex > 0){//如果有左兄弟,和左兄弟合并BTreeNode leftSibling = target.parent.children.get(parentChildIndex -1);//加上父结点的关键字parentValueIndex = parentChildIndex - 1;int downKey = target.parent.values.get(parentValueIndex);leftSibling.values.add(downKey);//加上目标结点的剩余信息leftSibling.values.addAll(target.values);target.children.forEach(c -> c.parent = leftSibling);leftSibling.children.addAll(target.children);} else{//没有左兄弟，和右兄弟合并BTreeNode rightSibling = target.parent.children.get(parentChildIndex + 1);//加上父结点关键字parentValueIndex = parentChildIndex;int downKey = target.parent.values.get(parentValueIndex);rightSibling.values.add(0,downKey);//加上目标结点的剩余信息rightSibling.values.addAll(0, target.values);target.children.forEach(c -> c.parent = rightSibling);rightSibling.children.addAll(0,target.children);}//递归删除父结点关键字和孩子return delete(target.parent,parentValueIndex,parentChildIndex);}}
}