编程内功修炼之数据结构—BTree（二）实现BTree插入、查询、删除操作

  1 package edu.algorithms.btree;

import java.util.ArrayList;
import java.util.List;

/**
 * BTree类
 * 
 * @author lingfeng
 *
 */
public class BTree {
    
    /**BTree 基础参数信息配置
    最小度数    t=2时，称作2-3-4数，表示只能存在2、3、4子女数**/
    private int t = 2;  
    
    /**非根节点最小关键字数**/
    private int minKeys = t-1;
    
    /**内节点最大关键字数**/
    private int maxKeys = 2*t - 1;
    
    /**树根节点**/
    private BTreeNode root;
    
    /**构造函数**/
    public BTree(){
        //初始化
        root = new BTreeNode();
        root.setLeaf(true);
    }
    /**构造函数  t 最小度数**/
    public BTree(int t){
        this();
        this.t  = t;
        minKeys = t - 1;
        maxKeys = 2*t - 1;
    }
    
    /**插入元素
     * 
     * 1.元素存在，插入元素
     * 2.元素不存在，插入元素
     * 
     * **/
    public void insertNode(Integer key){
        if(root.size() == maxKeys){   //根节点已满
            //进行根节点分割
            BTreeNode tmpNode = new BTreeNode();
            tmpNode.setLeaf(false);
            tmpNode.getChildrens().add(root);
            btreeSplitChild(tmpNode, 0, root);
            root = tmpNode;
        }
        insertRootNotFull(root, key);
    }
    
    public void insertRootNotFull(BTreeNode node, int key){
        
        //如果该节点为叶子节点
        if(node.isLeaf()){
            //寻找当前节点所有关键字
            ResultSearch result = divideSearch(node.getKeys(), key);
            //查询结果：成功  返回已经存在关键字位置
            if(result.result == true){
                
            }else{    //查询结果：失败   返回插入位置
                node.insertKey(key, result.index);
            }
            
        }else{
            //寻找当前节点所有关键字
            ResultSearch result = divideSearch(node.getKeys(), key);
            //查询结果：成功  返回已经存在关键字位置
            if(result.result == true){
                
            }else{    //查询结果：失败   返回插入子女节点的位置
                //判断子女状态
                BTreeNode childNode = node.childAt(result.index);
                if(node.childAt(result.index).size() == (2*t - 1)){
                    btreeSplitChild(node, result.index, childNode);
                    if(key > node.keyAt(result.index)){   //判断key落在 前半部分 或 后半部分
                        childNode = node.childAt(result.index + 1);
                    }
                }
                insertRootNotFull(childNode, key);
            }
        }
    }
    /**查询元素 (BTree查询)
     * 
     * 1.先查询节点的关键字列表
     * 2.失败则，查询子女节点；成功则，返回值
     * 3.递归搜索
     * 
     * **/
    public Integer search(BTreeNode node,Integer key){
        List<Integer> keys_tmp = node.getKeys();
        ResultSearch result = divideSearch(keys_tmp, key);
        if(result.result){
            return result.index;
        }else{
            return search(node.childAt(result.index), key);
        }
    }
    /**二分查询
     * 参数 元素列表、所需要查询元素的值
     * 
     * **/
    public ResultSearch divideSearch(List<Integer> elements, int key){
        
        int start = 0;    //扫描起始位置
        int end   = 0;    //扫描结束位置
        
        end = elements.size() - 1;
        
        int mid = 0; 
        while(start<=end){
            mid   = (start + end)/2;
            if(elements.get(mid) == key){ //满足等值条件
                break;
            }else if(elements.get(mid) > key){ //在列表前半部分
                //改变扫描结束位置
                end = mid - 1;
            }else if(elements.get(mid) <= key){
                //改变扫描开始位置
                start = mid + 1;
            }
        }
        
        boolean result = false;
        Integer index = 0;
        
        if(start<=end){  //二分查找成功
            result = true;
            index = mid;
        }else{    //查找失败，不存在元素
            result = false;
            index = start;
        }
        
        return new ResultSearch(result,index);
    }
    
    /**
     * 节点分割函数
     * @param parentNode  被分割节点的父节点
     * @param index  被分割节点在父节点的第index个子女索引位置
     * @param Node   被分割节点
     */
    public void btreeSplitChild(BTreeNode parentNode, int index, BTreeNode node){
        
        //新建一个节点，保存分割后[t+1 2t-1]数据
        BTreeNode subNode = new BTreeNode();
        //必须加上
        subNode.setLeaf(node.isLeaf());
        
        for(int i=1; i<=minKeys ; i++){
            subNode.getKeys().add(node.keyAt(t + i -1));
        }
        //保存分割点值[t]
        Integer key = node.keyAt(t - 1);
        //删除被分割节点的[t 2t-1]数据
        for(int i= maxKeys - 1; i>=minKeys; --i){
            node.getKeys().remove(i);
        }
        if(!node.isLeaf()){ //如果满节点不是叶节点，关键字分割后，需要将其子女进行操作
            
            //subNode应该拥有后半部分的子女
            for(int i=0 ; i<minKeys+1 ; ++i){
                subNode.getChildrens().add(node.childAt(i+t));
            }
            //并删除node后半部分的子女
            for(int i=maxKeys ; i>=minKeys+1; --i){
                node.getChildrens().remove(i);
            }
        }else{
            
        }
        //将[t]数据加入父节点中去
        parentNode.insertKey(key, index);
        //将新节点关联到父节点index+1子女中
        parentNode.insertChild(subNode, index+1);
    }
    public void delete(Integer key){
        delete(root, key);
    }
    
    public void delete(BTreeNode node, Integer key){
        //删除关键字时，必须保证关键字大于等于t
        assert node.size() >=t || node == root;
        
        //对当前节点进行二分查找
        ResultSearch resultSearch = divideSearch(node.getKeys(), key);
        
        //成功
        if(resultSearch.result){
            
            //如果当前节点属于叶子节点，可以直接进行删除
            if(node.isLeaf()){
                node.getKeys().remove(resultSearch.index.intValue());
            }else{
                //如果不是叶子节点 ，判断前于key子节点状态
                BTreeNode leftChildNode = node.childAt(resultSearch.index);
                if(leftChildNode.size() >= t){
                    
                    //从leftChildNode进行借值 代替当前需要删除的关键字
                    //删除当前节点关键字
                    node.getKeys().remove(resultSearch.index.intValue());
                    node.insertKey(leftChildNode.keyAt(leftChildNode.size()-1), resultSearch.index);
                    delete(leftChildNode, leftChildNode.keyAt(leftChildNode.size()-1));
                }else{
                    
                    BTreeNode rightChildNode = node.childAt(resultSearch.index + 1);
                    if(rightChildNode.size() >= t){
                        
                        //从rightChildNode进行借值 代替当前需要删除的关键字
                        node.getKeys().remove(resultSearch.index.intValue());
                        node.insertKey(rightChildNode.keyAt(0), resultSearch.index);
                        delete(rightChildNode, rightChildNode.keyAt(0));
                    }else{
                        
                        //对于索引的左右子节点的数量都等于t-1
                        //合适进行合并
                        //1.将父节点删除  将节点右子节点删除
                        node.getKeys().remove(resultSearch.index.intValue());
                        node.getChildrens().remove(resultSearch.index.intValue() + 1);
                        //2.将父节点添加到左子节点上
                        leftChildNode.getKeys().add(key);
                        //3.将删除的右子节点添加到左子节点上
                        for(int i=0 ; i<rightChildNode.size() ; i++){
                            leftChildNode.getKeys().add(rightChildNode.getKeys().get(i));
                        }
                        //如果右子节点非叶子节点，需要将其子女继承到左节点之下
                        if(!rightChildNode.isLeaf()){
                            for(int k=0 ; k<=rightChildNode.size() ; k++){
                                leftChildNode.getChildrens().add(rightChildNode.childAt(k));
                            }
                        }
                        //递归删除
                        delete(leftChildNode, key);
                        
                    }
                }
                
            }
            
        }else{ //失败
            if(node.isLeaf()){
                //不存在删除的对象
                System.out.println("不存在删除的对象");
                return ;
            }
            
            //获取子节点
            BTreeNode childNode = node.childAt(resultSearch.index);
            
            if(root == node && node.size()==0){
                root = childNode;
            }
            
            if(childNode.size() >= t){   //如果满足递归条件
                delete(childNode, key);
            }else{
                //不满足size == t
                //采取借关键字手段
                
                BTreeNode subNode = null;
                int subIndex = 0;
                //先检测右兄弟节点
                if(resultSearch.index < node.size()){
                    if(node.childAt(resultSearch.index+1).size() >=t){
                        subNode  = node.childAt(resultSearch.index+1);
                        subIndex = resultSearch.index + 1;
                    }
                }
                //测试左兄弟节点
                if(subNode == null){
                    if(resultSearch.index > 0){
                        if(node.childAt(resultSearch.index-1).size() >= t){
                            subNode  = node.childAt(resultSearch.index-1);
                            subIndex = resultSearch.index - 1;
                        }
                    }
                }
                //测试完成后
                if(subNode != null){  //存在兄弟节点大于等于t情况
                    //判断节点
                    if(subIndex > resultSearch.index){ //右兄弟
                        
                        //将右关键字插入自身
                        childNode.insertKey(node.keyAt(subIndex - 1), childNode.size());
                        node.getKeys().remove(subIndex - 1);
                        node.insertKey(subNode.keyAt(0), subIndex - 1);
                        subNode.getKeys().remove(0);
                        
                        //右兄弟非子叶节点，则带有孩子节点
                        if(!subNode.isLeaf()){
                            childNode.getChildrens().add(subNode.getChildrens().get(0));
                            subNode.getChildrens().remove(0);
                        }
                        
                    }else{  //左兄弟
                        
                        //将左关键字插入自身最前位置
                        childNode.insertKey(node.keyAt(subIndex), 0);
                        node.getKeys().remove(subIndex);
                        node.insertKey(subNode.keyAt(subNode.size()-1), subIndex);
                        subNode.getKeys().remove(subNode.size()-1);
                        
                        //如果左兄弟非子叶节点
                        if(!subNode.isLeaf()){
                            childNode.insertChild(subNode.childAt(subNode.size()), 0);
                            subNode.getChildrens().remove(subNode.size()-1);
                        }    
                    }
                    delete(childNode, key);
                    
                }else{
                    
                    //该节点的左右兄弟节点关键字都为t-1
                    //选择合并方案
                    if(resultSearch.index < node.size()){   //右兄弟存在
                        
                        subNode = node.childAt(resultSearch.index + 1);
                        
                        //childNode.getKeys().add(node.keyAt(resultSearch.index + 1));
                        childNode.getKeys().add(node.keyAt(resultSearch.index));
                        
                        node.getKeys().remove(resultSearch.index.intValue());
                        node.getChildrens().remove(resultSearch.index.intValue());
                        
                        for(int i=0 ; i<subNode.size() ; i++){
                            childNode.getKeys().add(subNode.keyAt(i));
                        }
                        
                        if(!subNode.isLeaf()){
                            for(int k=0 ; k<=subNode.size(); k++){
                                childNode.getChildrens().add(subNode.childAt(k));
                            }
                        }
                        
                    }else{      //左兄弟存在
                        
                        subNode = node.childAt(resultSearch.index - 1);
                        childNode.insertKey(node.keyAt(resultSearch.index-1), 0);
                        node.getKeys().remove(resultSearch.index - 1);
                        node.getChildrens().remove(resultSearch.index-1);
                        
                        for(int i=subNode.size()-1 ; i>=0 ; --i){
                            childNode.insertKey(subNode.keyAt(i), 0);
                        }
                        
                        if(!subNode.isLeaf()){
                            for(int k=subNode.size() ; k>=0 ; --k){
                                childNode.insertChild(subNode.childAt(k),0);
                            }
                        }
                        
                    }
                    if(root == node && node.size() == 0){
                        root = childNode;
                    }
                    delete(childNode, key);
                }
            }
            
        }
    }
    
}
class BTreeNode{
    
    /**当前节点keys列表**/
    private List<Integer> keys; 

    /**当前节点的child列表**/
    private List<BTreeNode> childrens;
    
    /**是否是叶子节点**/
    private boolean leaf;
    
    public BTreeNode(){
        keys      = new ArrayList<Integer>();
        childrens = new ArrayList<BTreeNode>();
        leaf = true;
    }
    /**
     * set and get methods
     * 
     * **/
    public List<Integer> getKeys() {
        return keys;
    }
    public void setKeys(List<Integer> keys) {
        this.keys = keys;
    }
    public List<BTreeNode> getChildrens() {
        return childrens;
    }
    public void setChildrens(List<BTreeNode> childrens) {
        this.childrens = childrens;
    }
    public boolean isLeaf() {
        return leaf;
    }
    public void setLeaf(boolean leaf) {
        this.leaf = leaf;
    }
    
    /**
     * 获取子女节点
     * @param index
     * @return
     */
    public BTreeNode childAt(int index){
        return childrens.get(index);
    }
    /**
     * 获取关键字
     * @param index
     * @return
     */
    public Integer keyAt(int index){
        return keys.get(index);
    }
    
    /**
     * 获取节点关键字数量
     * @return
     */
    public int size(){
        return keys.size();
    }
    
    /**
     * 插入key到指定的index中去
     * @param key
     * @param index
     */
    public void insertKey(Integer key, int index){
        //插入key到指定的索引位置
        //保存索引前的所有关键字
        List<Integer> newlist = new ArrayList<Integer>();
        
        for(int i=0; i<index ; i++){
            newlist.add(keys.get(i));
        }
        //插入关键字
        newlist.add(key);
        //保存索引后多关键字
        for(int i=index ; i<keys.size() ; i++){
            newlist.add(keys.get(i));
        }
        //将新的关键字集合设置为节点关键字集合对象
        keys = newlist;
    }
    
    /**
     * 插入node子女到指定的index位置
     * @param node
     * @param index
     */
    public void insertChild(BTreeNode node, int index){
        //插入child
        List<BTreeNode> newlist = new ArrayList<BTreeNode>();
        for(int i=0 ; i< index ; i++){
            newlist.add(childrens.get(i));
        }
        newlist.add(node);
        for(int i=index ; i<childrens.size() ; i++){
            newlist.add(childrens.get(i));
        }
        childrens = newlist;
    }
}
/**
 * 查询结果类
 * result 标识成功的状态 true or false
 * index 成功后返回元素的索引
 *       失败后返回元素的插入位置 
 * @author lingfeng
 */
class ResultSearch{
    
    public Integer index;
    public boolean result;
    
    public ResultSearch(boolean rs, Integer i){
        index  = i;
        result = rs;
    }
}