自己寫的java實現的多路搜索樹 B-Tree

最近需要寫范圍查詢的功能，最簡單的應該是B+樹吧，在了解B+樹的時候，也看到了B-樹。於是想先實現B-Tree再實現B+Tree，結果網上並沒有找到B-Tree（多路搜索樹），於是自己用java實現了一個，經過自己設計了很多測試用例，用Junit（臨時學的）測試可用。在這里貼出來，希望能給初學者一點參考，也希望能有高人指點可以改進的地方，歡迎討論批評指點！自己之前一直在做工程，這是一年多來首次寫數據結構，自己還很弱，歡迎大家批評指正！！！

本B-Tree理論部分參考博客：http://blog.csdn.net/v_JULY_v/article/details/6530142/

以下直接貼代碼！

 

package com.test1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;

/**
 * Created by MSI on 2016/1/5.
 *  該程序參考文章：http://blog.csdn.net/v_JULY_v/article/details/6530142/
 */
public class BsubTree<T extends Comparable<T>> {

    private static BsubTree<Integer> tree = new BsubTree<Integer>();
    private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

    int m = 4;      //此B-樹的階數。關鍵字數等於階數-1。m至少為2，m必須大於等於2。
    int n;      //n是關鍵字最小個數
    public BTNode root;

    public BsubTree(){
        root = new BTNode(null,null);
        if(m>=2){
            if(m%2==0){
                n = m/2-1;
            }else {
                n = m/2;
            }
        }else {
            System.out.println("error");
            System.exit(0);
        }
    }

    public BsubTree(BTNode root){
        this.root = root;
        if(m%2==0){
            n = m/2;
        }else {
            n = m/2+1;
        }
    }

    public BTNode findNode(T information){
        return findNode(information, root);
    }   //isMember應該返回插入點

    private BTNode findNode(T info, BTNode node){   //不論是否找到都返回一個node。
        BTNode member = null;

        if(node.informations.size()==0){//這種情況存在,只有root可能
            member = node;
            //System.out.println("error");
        }else {
            if(info.compareTo(node.informations.get(node.informations.size()-1))>0) {    //info比節點最大的還大，則直接進入最右分支
                    if(node.ptr.size()>0){//有孩子的情況，進入范圍中的子節點
                        member = findNode(info, node.ptr.get(node.informations.size()));
                    }else {//沒有子節點，直接返回node
                        member = node;
                    }
            }else {//沒有判斷沒有子節點的情況，上一個if中判斷了，這一個else中就忘了，怒
                if(node.ptr.size()>0){//有子節點
                    if(info.compareTo(node.informations.get(0))<0){
                        member = findNode(info, node.ptr.get(0));
                    }else {
                        for(int i = 0;i<node.informations.size();++i){
                            if(info.compareTo(node.informations.get(i))==0){
                                member = node;
                                break;
                            }else if(info.compareTo(node.informations.get(i))>0&&info.compareTo(node.informations.get(i+1))<0){   //只要不是最右，info比之大的，進入它的孩子節點
                                member = findNode(info, node.ptr.get(i+1));
                                break;
                            }
                        }
                    }
                }else {//沒有子節點
                    member = node;
                }
            }
        }
        return member;
    }

    public void insert(T info){
        BTNode temp = findNode(info);
        if(temp.informations.size()!=0){
            for(T i:temp.informations){
                if(i.compareTo(info)==0){
                    System.out.println("已存在所插入的值。");
                    return;
                }
            }
        }
        insert(info,temp,temp.parent);
        return;
    }

    private void insert(T info,BTNode node,BTNode parent){//插入一定是在葉子節點
        if(node == null){//insert中的node為空應該只有一種情況，node=root
            if(parent == null){
                root = new BTNode(info,parent);
            }else {
                System.out.println("不應該出現的情況，請檢查。");
                //node = new BTNode(info,parent);
            }
        }else{
            if(node.informations.size()==0){
                //System.out.println("這種情況應該不存在，請檢查代碼");//現在存在這種情況啦
                node.informations.add(info);
            }else if(node.informations.size()>0 && node.informations.size()<m-1){
                if(info.compareTo(node.informations.get(node.informations.size() - 1))>0){//info比node最右邊最大的值還大，則直接插入
                    node.informations.add(info);
                }else {
                    for (int i = 0; i < node.informations.size(); ++i) {
                        if (info.compareTo(node.informations.get(i)) < 0) {
                            node.informations.add(i, info);
                            break;
                        }
                    }
                }
            }else if(node.informations.size()==m-1){//需要分裂
                if(info.compareTo(node.informations.get(node.informations.size()-1))>0){//info比node最右邊最大的值還大，則直接插入
                    node.informations.add(info);
                }else {
                    for(int i = 0;i<node.informations.size();++i){
                        if(info.compareTo(node.informations.get(i))<0){
                            node.informations.add(i,info);
                            break;
                        }
                    }
                }

                split(node);
            }else {
                System.out.println("node 的size大於等於m-1，不應該出現，請檢查代碼");
            }
        }
    }

    public void delete(T info){
        BTNode temp = findNode(info,root);
        if(temp.informations.size()==0){
            System.out.println("根節點為空！");
            return;
        }
        for(T i:temp.informations){
            if(info.compareTo(i)==0){
                delete(info,temp);
                break;
            }else if(temp.informations.indexOf(i)==temp.informations.size()-1){//循環到最后一個值了，仍到這里，說明不存在要刪除的值！
                System.out.println("不存在要刪除的值！");
            }
        }
    }

    private void delete(T info,BTNode node)throws NoSuchElementException {
        if (node == null) { //其實到這里，就一定存在要刪除的值了。
            throw new NoSuchElementException();
        }else {
            int i;
            for(i=0;i<node.informations.size();i++){
                if(info.compareTo(node.informations.get(i))==0){
                    node.informations.remove(i);    //刪除關鍵字，其實要是索引向文件，也應該刪除文件。
                    break;
                }
            }
            if(node.ptr.size()>0){//刪除一個非葉子節點的關鍵字后，如果有孩子，則判斷孩子的孩子，如果孩子有孩子，則將右孩子的孩子最深左孩子的第一個值賦給刪除關鍵字的節點
                //每一個關鍵字，一定有兩個孩子
                if(node.ptr.get(i+1).ptr.size()==0){//孩子沒有孩子的時候，只將孩子的最左關鍵字上升。
                    node.informations.add(i,node.ptr.get(i+1).informations.get(0));
                    node.ptr.get(i+1).informations.remove(0);
                    if(node.ptr.get(i+1).informations.size()<n){
                        dManageNode(node.ptr.get(i+1));
                    }
                }else {//孩子有孩子的時候，則將右孩子的孩子最深左孩子的第一個值賦給刪除關鍵字的節點
                    pullRLeftNode(node,i,node.ptr.get(i+1),i);
                }

            }else {//如果沒有孩子，要判斷該節點關鍵字數量是否大於最小值
                if(node.informations.size()>=n){//大於等於就沒事，不用動
                    return;
                }else {//葉子節點中關鍵字數小於n，需要繼續判斷兄弟節點是否飽滿
                    dManageNode(node);
                }
            }
        }
    }

    public String perOrder(BTNode node){
        String result = "";
        if(node.ptr.size()>0){
            int i = 0;
            for (BTNode n:node.ptr){
                result += perOrder(n);
                if(i<node.informations.size()){
                    result += node.informations.get(i).toString()+",";
                    ++i;
                }
            }
        }else {//葉子節點
            if(node.informations.size()>0){
                for (T t:node.informations){
                    result += t.toString()+",";
                }
            }else {//葉子節點沒有空值的時候，除非是根節點，根節點為空值的時候，說句話意思意思
                result += "B-樹為空！";
            }
        }
        return result;
    }

    public void split(BTNode node){//進到這里的node都是m個關鍵字，需要提出m/2
        if(node == null){
            System.out.println("error");
        }else {
            if(node.informations.size()!=m){
                System.out.println("error");
            }else {
                if(node.parent == null){//node是root時
                    T temp = node.informations.get(n);//這里正好
                    root = new BTNode(temp,null);
                    node.informations.remove(n);//加進去了就要刪掉！
                    root.ptr.add(node);
                    node.parent=root;
                    splitNewNode(node,n,root);
                }else {//一個非根節點
                    T temp = node.informations.get(n);
                    node.parent.informations.add(node.parent.ptr.indexOf(node),temp);
                    node.informations.remove(n);
                    splitNewNode(node,n,node.parent);
                    if (node.parent.informations.size()>=m){
                        split(node.parent);
                    }
                }
            }
        }
    }

    public void splitNewNode(BTNode node,int n,BTNode parent){
        BTNode newnode = new BTNode(node.informations.get(n),node.parent);

        newnode.informations.addAll(node.informations.subList(n+1,node.informations.size()));

        node.informations.removeAll(node.informations.subList(n,node.informations.size()));
        //newnode.parent=node.parent;//新增節點的父節點
        node.parent.ptr.add(node.parent.ptr.indexOf(node)+1,newnode);   //新增節點加到父節點上
        if(node.ptr.size()>0){  //處理新增節點的孩子
            newnode.ptr.addAll(node.ptr.subList(n+1,node.ptr.size()));
            node.ptr.removeAll(node.ptr.subList(n+1,node.ptr.size()));
            for (BTNode bn:newnode.ptr){    //子節點移到了新節點上，但是子節點的父節點沒有處理！！！T_T
                bn.parent = newnode;
            }
        }

    }

    public void combine(BTNode lnode,BTNode rnode){
        if(lnode.informations.size()<n){
            lnode.informations.add(lnode.parent.informations.get(lnode.parent.ptr.indexOf(lnode)));
            lnode.parent.informations.remove(lnode.parent.ptr.indexOf(lnode));
        }else if(rnode.informations.size()<n){
            rnode.informations.add(0,rnode.parent.informations.get(lnode.parent.ptr.indexOf(lnode)));
            rnode.parent.informations.remove(lnode.parent.ptr.indexOf(lnode));
        }else {
            System.out.println("error");
        }

        lnode.informations.addAll(rnode.informations);
        lnode.ptr.addAll(rnode.ptr);
        for (BTNode n:rnode.ptr){
            n.parent=lnode;
        }
        lnode.parent.ptr.remove(lnode.parent.ptr.indexOf(lnode)+1);
        if(lnode.parent.parent==null&&lnode.parent.informations.size()==0){//父節點是根節點
            lnode.parent = null;    //lnode為新的根節點
            root = lnode;
            return;
        }
        if(lnode.parent.informations.size()<n){
            dManageNode(lnode.parent);
        }
    }

    public void lrotate(BTNode lnode,BTNode rnode){
        lnode.informations.add(lnode.parent.informations.get(lnode.parent.ptr.indexOf(lnode)));
        lnode.parent.informations.remove(lnode.parent.ptr.indexOf(lnode));
        lnode.parent.informations.add(lnode.parent.ptr.indexOf(lnode),rnode.informations.get(0));
        rnode.informations.remove(0);
        if(rnode.ptr.size()>0){//要判斷葉子節點沒有孩子！
            lnode.ptr.add(rnode.ptr.get(0));
            rnode.ptr.remove(0);
            lnode.ptr.get(lnode.ptr.size()-1).parent=lnode;
        }

    }

    public void rrotate(BTNode lnode,BTNode rnode){
        rnode.informations.add(rnode.parent.informations.get(lnode.parent.ptr.indexOf(lnode)));
        rnode.parent.informations.remove(lnode.parent.ptr.indexOf(lnode));
        rnode.parent.informations.add(lnode.parent.ptr.indexOf(lnode),lnode.informations.get(lnode.informations.size()-1));
        lnode.informations.remove(lnode.informations.size()-1);
        if(lnode.ptr.size()>0){
            rnode.ptr.add(0,lnode.ptr.get(lnode.ptr.size()-1));
            lnode.ptr.remove(lnode.ptr.size()-1);
            rnode.ptr.get(0).parent=rnode;
        }
    }

    public void dManageNode(BTNode node){//葉子節點中關鍵字數小於n，需要繼續判斷兄弟節點是否飽滿，是旋轉還是合並
        if(node.parent==null){
            return;
        }else {
            int x = node.parent.ptr.indexOf(node);
            if(x==0){//被刪除關鍵字所在節點，是父節點最左邊的節點時，判斷右兄弟，而且肯定有右兄弟
                if(node.parent.ptr.get(x+1).informations.size()==n){//剛脫貧，需要合並
                    combine(node,node.parent.ptr.get(x+1));
                }else if(node.parent.ptr.get(x+1).informations.size()>n){//關鍵字數大於最小值，豐滿
                    lrotate(node, node.parent.ptr.get(x + 1));
                }else {
                    System.out.println("error");
                }
            }else if(x==node.parent.ptr.size()-1){//是父節點最右邊的節點時，判斷左兄弟
                if(node.parent.ptr.get(x-1).informations.size()==n){//左兄弟剛脫貧，需要合並
                    combine(node.parent.ptr.get(x-1),node);
                }else if(node.parent.ptr.get(x-1).informations.size()>n){//關鍵字數大於最小值，豐滿
                    rrotate(node.parent.ptr.get(x-1),node);
                }else {
                    System.out.println("error");
                }
            }else {//node在父節點的子節點的中間，需要先判斷左兄弟，再判斷右兄弟。靠，感覺判斷兄弟是否飽滿，還是應該寫一個函數，也許可以傳遞兩個值
                //先跟飽滿的借，除非兩個兄弟都剛脫貧。
                if(node.parent.ptr.get(x-1).informations.size()>n){//左兄弟豐滿
                    rrotate(node.parent.ptr.get(x - 1),node);
                }else if(node.parent.ptr.get(x+1).informations.size()>n){//右兄弟豐滿
                    lrotate(node, node.parent.ptr.get(x + 1));
                }else{//左右兄弟都剛脫貧，需要合並
                    combine(node.parent.ptr.get(x-1),node);
                }
            }
        }

    }

    public void pullRLeftNode(BTNode donode,int j,BTNode node,int i){//節點刪除關鍵字后，如果該節點有孩子，則孩子需要貢獻關鍵字，由於孩子減少了關鍵字還需要向下借，一直遞歸到葉子。

        if(node.ptr.get(0).ptr.size()>0){
            pullRLeftNode(donode,j,node.ptr.get(0),0);
        }else {
            donode.informations.add(j,node.ptr.get(0).informations.get(0));
            node.ptr.get(0).informations.remove(0);
            if(node.ptr.get(0).informations.size()<n){
                dManageNode(node.ptr.get(0));
            }
        }
    }

    class BTNode{
        BTNode parent;  //父節點
        List<T> informations = new ArrayList<T>();  //關鍵字的信息
        List<BTNode> ptr = new ArrayList<BTNode>();     //分支

        public BTNode(T information,BTNode parent){
            if(information != null){
                informations.add(information);
                this.parent = parent;
            }else {
                this.parent = null;
            }
        }

        boolean isLeaf(){
            return (ptr.size()==0);
        }

        boolean isNode(){
            return (ptr.size()!=0);
        }

        int infoLength(){
            return informations.size();
        }

        int ptrLength(){
            return ptr.size();
        }

    }

    private static String stringInput(String inputRequest)throws IOException{
        System.out.println(inputRequest);
        return reader.readLine();
    }

    public static void main(String[] args)throws IOException {
        System.out.println("test B - balanced tree operations");
        System.out.println("*****************************");

        String input;
        Integer value;

        do {
            input = stringInput("please select: [i]nsert, [d]elete, [s]how, [e]xit");
            switch (input.charAt(0)) {
                case 'i':
                    value = Integer.parseInt(stringInput("insert: "), 10);
                    tree.insert(value);
                    break;
                case 'd':
                    value = Integer.parseInt(stringInput("delete: "), 10);
                    tree.delete(value);
                    break;
                case 's':
                    System.out.println(tree.perOrder(tree.root));
                    break;
//                case 'h':
//                    System.out.println(tree.getHeight());
            }
        } while ((input.charAt(0) != 'e'));
    }
}