B树、B+树的java实现

一、B树的定义

在定义B树之前，首先明确一个概念，就是什么是树的阶？
树的阶指的是一个结点最多能有多少棵子树。例如：二叉树的阶就是2。

这个要跟结点的度区分开来，度是基于单个结点的，而阶是针对整棵树的。可以理解为树的阶是用来限制每个结点的度的。

B树，又称B-树，一棵m阶的B树，或为空树，或为满足下列特性的m叉树：
（1）树中每个结点至多有m棵子树。【解释：因为树的阶是m，所有这个是必然】
（2）若根结点不是叶子节点，则至少有两棵子树。
（3）除根结点之外的所有非叶子结点至少有⌈m/2⌉棵子树。【解释：第一条是用来限制所有节点度的最大值，2、3两条是用来限制根结点和非叶子结点度的最小值】
（4）所有的非叶子结点中包含下列信息数据
(n,P0,K0,P1,K1,P2,···,Kn-1,Pn)
其中，K[i] (i=0,···,n-1)为关键字，切K[i] < K[i+1](i=0,···,n-1)，P[i] (i=0,1,···,n-1)为指向子树根结点的指针，且指针P[i]所指向的子树中的所有结点的关键字均小于K[i] (i=0,···,n-1)，P[i+1]所指向的子树中的所有结点的关键字均大于K[i]。n为关键字的关键字的个数，且⌈m/2⌉-1 ≤ n ≤ m-1。【解释：指的关键字的左子树都比它小，右子树都比它大】
（5）所有叶子结点位于同一层

示例，3阶B树（m=3）：

二、B树的增删改查

1、B树的模型

package com.ghs.algorithm;import java.util.List;public class BTNode<K extends Comparable> {    /** 关键字的个数 */    private int number = 0;    /** 关键字，0号单元未使用 */    private List<K> keys;    /** 子树 */    private List<BTNode> children;}

package com.ghs.algorithm;public class BTree<K extends  Comparable<K>>{    /** 根节点 */    private BTNode root;    /** 阶 */    private int order;}

2、B树的查找操作

    /**     * @title 查询key     * @author ghs     * @date 2017/11/10 21:53     * @param     * @return     */    public Result getKey(K key){        BTNode preNode = null;        BTNode node = root;        boolean found = false;        int i = 0;        while (node != null && !found){            i = index(node, key);            if(node.getKey(i).equals(key)){                found = true;            }else{                preNode = node;                node = node.getChildren(i);            }        }        return new Result(found ? node:preNode, i, found);    }    /**     * @title 查找key在node中的位置     * @author ghs     * @date 2017/11/10 19:41     * @param     * @return     */    private int index(BTNode<K> node, K key){        //在keys[1...keyNum]中查找，使得keys[i]<= key < keys[i+1]（0<i<keyNum-1）        for (int i=0; i<node.getNumber(); i++){            if (key.compareTo(node.getKey(i)) <= 0){                return i;            }        }        return node.getNumber();    }

3、B树的插入

    public void addKey(K key){        Result result = getKey(key);        BTNode<K> node = result.getNode();        int position = result.getPosition();        K k = key;        BTNode<K> rightNode = null;        while (node!=null){            add(node, position, k, rightNode);            int number = node.getNumber();            if(number < order){                return;            }else {                int s = number%2==0 ? number/2 : number/2+1;                split(node, s, rightNode);                k = node.getKey(s);                node = node.getParent();                if (node != null) {                    position = index(node, k);                }            }        }        newRoot(key);    }    private void split(BTNode<K> node, int s, BTNode<K> newNode){        int number = node.getNumber();        List<K> keys = node.getKeys();        List<BTNode> children = node.getChildren();        node.setKeys(keys.subList(0, s-1));        node.setChildren(children.subList(0, s));        node.setNumber(s-1);        newNode.setKeys(keys.subList(s, number-1));        newNode.setChildren(children.subList(s, number));        newNode.setNumber(number-s);    }    private BTNode newRoot(K key){        BTNode node = new BTNode();        node.addKey(0, key);        node.addChildren(0, nullBTNode);        node.addChildren(1, nullBTNode);        node.setNumber(1);        return node;    }