B+樹的算法（java實現）

• 定義

　　一顆m階B+樹滿足以下幾個條件：

　　1.除根節點外的節點的關鍵字個數最大為m-1,最小為m/2

　　2.除葉節點外的每個節點的孩子節點的數目為該節點關鍵字個數加一，這些孩子節點的的關鍵字的范圍與父節點關鍵字的大小對應（這個看圖才看的清楚）

　　3.葉子節點存放着所有的關鍵字，葉子節點間按關鍵字的大小用指針相互連接。內部節點以葉子節點的關鍵字的最小值作為索引

• B+樹的優勢

　　B+樹相較於B樹最大的優勢在於數據全部都存在於葉子節點，葉子節點間以指針相互連接，這樣在進行按照索引的范圍查找的時候就只需要遍歷前后指針就可以完成，而B樹要一個一個索引去進行查找，效率差別很大。

　　B+樹相較於hash的優勢在於B+樹不用一次將數據全部加載到內存，而是先確定要查詢索引的地址，將對應的地址的索引加載到內存。而hash需要將全部的數據一次性加載到內存才能完成查找。

• B+樹代碼實現

　　首先定義一個節點類

import java.util.List;

/*節點類*/
public class Node {

    //節點的子節點
    private List<Node> nodes;
    //節點的鍵值對
    private List<KeyAndValue> keyAndValue;
    //節點的后節點
    private Node nextNode;
    //節點的前節點
    private Node previousNode;
    //節點的父節點
    private Node parantNode;

    public Node( List<Node> nodes, List<KeyAndValue> keyAndValue, Node nextNode,Node previousNode, Node parantNode) {
        this.nodes = nodes;
        this.keyAndValue = keyAndValue;
        this.nextNode = nextNode;
        this.parantNode = parantNode;
        this.previousNode = previousNode;
    }

     boolean isLeaf() {
        return nodes==null;
    }

     boolean isHead() {
        return previousNode == null;
    }

     boolean isTail() {
        return nextNode == null;
    }

     boolean isRoot() {
        return parantNode == null;
    }


     List<Node> getNodes() {
        return nodes;
    }

     void setNodes(List<Node> nodes) {
        this.nodes = nodes;
    }


    List<KeyAndValue> getKeyAndValue() {
        return keyAndValue;
    }

//    public void setKeyAndValue(List<KeyAndValue> KeyAndValue) {
//        this.keyAndValue = KeyAndValue;
//    }

    Node getNextNode() {
        return nextNode;
    }

     void setNextNode(Node nextNode) {
        this.nextNode = nextNode;
    }

     Node getParantNode() {
        return parantNode;
    }

     void setParantNode(Node parantNode) {
        this.parantNode = parantNode;
    }

     Node getPreviousNode() {
        return previousNode;
    }

     void setPreviousNode(Node previousNode) {
        this.previousNode = previousNode;
    }
}

 　　定義一個存儲關鍵字和數據的類

public class KeyAndValue implements Comparable<KeyAndValue>{
    /*存儲索引關鍵字*/
    private int key;
    /*存儲數據*/
    private Object value;

    @Override
    public int compareTo(KeyAndValue o) {
        //根據key的值升序排列
        return this.key - o.key;
    }

    public int getKey() {
        return key;
    }

    public void setKey(int key) {
        this.key = key;
    }

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }

     KeyAndValue(int key, Object value) {
        this.key = key;
        this.value = value;
    }
}

 　　最后是具體的實現代碼

import java.util.*;


public class Btree {
    private static final String NODE = "NODE";
    static final String INT = "INT";
    private static final String PRENODE = "PRENODE";
    private static final String NEXTNODE = "NEXTNODE";
    //B+樹的階數
    private int rank;
    //根節點
    private Node root;
    //頭結點
    private Node head;

    Btree(int rank) {
        this.rank = rank;
    }

    public Node getRoot() {
        return root;
    }

    public void insert(KeyAndValue entry) {
        List<KeyAndValue> keyAndValues1 = new ArrayList<>();
        //插入第一個節點
        if (head == null) {
            keyAndValues1.add(entry);
            head = new Node(null, keyAndValues1, null, null, null);
            root = new Node(null, keyAndValues1, null, null, null);
        } else {
            Node node = head;
            //遍歷鏈表，找到插入鍵值對對應的節點
            while (node != null) {
                List<KeyAndValue> keyAndValues = node.getKeyAndValue();
                int exitFlag = 0;
                //如果插入的鍵的值和當前節點鍵值對集合中的某個鍵的值相等，則直接替換value
                for (KeyAndValue KV : keyAndValues) {
                    if (KV.getKey() == entry.getKey()) {
                        KV.setValue(entry.getValue());
                        exitFlag = 1;
                        break;
                    }
                }
                //如果插入的鍵已經有了，則退出循環
                if (exitFlag == 1) {
                    break;
                }
                //如果當前節點是最后一個節點或者要插入的鍵值對的鍵的值小於下一個節點的鍵的最小值，則直接插入當前節點
                if (node.getNextNode() == null || node.getNextNode().getKeyAndValue().get(0).getKey() >= entry.getKey()) {
                    splidNode(node, entry);
                    break;
                }
                //移動指針
                node = node.getNextNode();
            }
        }
    }


    //判斷是否需要拆分節點
    private void splidNode(Node node, KeyAndValue addkeyAndValue) {
        List<KeyAndValue> keyAndValues = node.getKeyAndValue();

        if (keyAndValues.size() == rank - 1) {
            //先插入待添加的節點
            keyAndValues.add(addkeyAndValue);
            Collections.sort(keyAndValues);
            //取出當前節點的鍵值對集合
            //取出原來的key-value集合中間位置的下標
            int mid = keyAndValues.size() / 2;
            //取出原來的key-value集合中間位置的鍵
            int midKey = keyAndValues.get(mid).getKey();
            //構造一個新的鍵值對，不是葉子節點的節點不存儲value的信息
            KeyAndValue midKeyAndValue = new KeyAndValue(midKey, "");
            //將中間位置左邊的鍵值對封裝成集合對象
            List<KeyAndValue> leftKeyAndValues = new ArrayList<>();
            for (int i = 0; i < mid; i++) {
                leftKeyAndValues.add(keyAndValues.get(i));
            }
            //將中間位置右邊邊的鍵值對封裝成集合對象
            List<KeyAndValue> rightKeyAndValues = new ArrayList<>();
            //如果是葉子節點則在原節點中保留上移的key-value，否則原節點刪除上移的key-value
            int k;
            if (node.isLeaf()) {
                k = mid;
            } else {
                k = mid + 1;
            }
            for (int i = k; i < rank; i++) {
                rightKeyAndValues.add(keyAndValues.get(i));
            }
            //對左右兩邊的元素重排序
            Collections.sort(leftKeyAndValues);
            Collections.sort(rightKeyAndValues);
            //以mid為界限將當前節點分列成兩個節點，維護前指針和后指針
            Node rightNode;
            Node leftNode;
//            if (node.isLeaf()) {
            //如果是葉子節點維護前后指針
            rightNode = new Node(null, rightKeyAndValues, node.getNextNode(), null, node.getParantNode());
            leftNode = new Node(null, leftKeyAndValues, rightNode, node.getPreviousNode(), node.getParantNode());
            rightNode.setPreviousNode(leftNode);
//            } else {
//                //如果不是葉子不維護前后指針
//                rightNode = new Node(null, rightKeyAndValues, null, null, node.getParantNode());
//                leftNode = new Node(null, leftKeyAndValues, null, null, node.getParantNode());
//            }
            //如果當前分裂的節點有孩子節點,設置分裂后節點和孩子節點的關系
            if (node.getNodes() != null) {
                //取得所有地孩子節點
                List<Node> nodes = node.getNodes();
                List<Node> leftNodes = new ArrayList<>();
                List<Node> rightNodes = new ArrayList<>();
                for (Node childNode : nodes) {
                    //取得當前孩子節點的最大鍵值
                    int max = childNode.getKeyAndValue().get(childNode.getKeyAndValue().size() - 1).getKey();
                    if (max < midKeyAndValue.getKey()) {
                        //小於mid處的鍵的數是左節點的子節點
                        leftNodes.add(childNode);
                        childNode.setParantNode(leftNode);
                    } else {
                        //大於mid處的鍵的數是右節點的子節點
                        rightNodes.add(childNode);
                        childNode.setParantNode(rightNode);
                    }
                }
                leftNode.setNodes(leftNodes);
                rightNode.setNodes(rightNodes);
            }

            //當前節點的前節點
            Node preNode = node.getPreviousNode();
            //分裂節點后將分裂節點的前節點的后節點設置為左節點
            if (preNode != null) {
                preNode.setNextNode(leftNode);
            }

            //當前節點的后節點
            Node nextNode = node.getNextNode();
            //分裂節點后將分裂節點的后節點的前節點設置為右節點
            if (nextNode != null) {
                nextNode.setPreviousNode(rightNode);
            }

            //如果由頭結點分裂，則分裂后左邊的節點為頭節點
            if (node == head) {
                head = leftNode;
            }

            //父節點的子節點
            List<Node> childNodes = new ArrayList<>();
            childNodes.add(rightNode);
            childNodes.add(leftNode);
            //分裂
            //當前節點無父節點
            if (node.getParantNode() == null) {
                //父節點的鍵值對
                List<KeyAndValue> parentKeyAndValues = new ArrayList<>();
                parentKeyAndValues.add(midKeyAndValue);
                //構造父節點
                Node parentNode = new Node(childNodes, parentKeyAndValues, null, null, null);
                //將子節點與父節點關聯
                rightNode.setParantNode(parentNode);
                leftNode.setParantNode(parentNode);
                //當前節點為根節點
                root = parentNode;
            } else {
                Node parentNode = node.getParantNode();
                //將原來的孩子節點（除了被拆分的節點）和新的孩子節點（左孩子和右孩子）合並之后與父節點關聯
                childNodes.addAll(parentNode.getNodes());
                //移除正在被拆分的節點
                childNodes.remove(node);
                //將子節點與父節點關聯
                parentNode.setNodes(childNodes);
                rightNode.setParantNode(parentNode);
                leftNode.setParantNode(parentNode);
                if (parentNode.getParantNode() == null) {
                    root = parentNode;
                }
                //當前節點有父節點,遞歸調用拆分的方法,將父節點拆分
                splidNode(parentNode, midKeyAndValue);
            }
        } else {
            keyAndValues.add(addkeyAndValue);
            //排序
            Collections.sort(keyAndValues);
        }
    }


    //打印B+樹
    void printBtree(Node root) {
        if (root == this.root) {
            //打印根節點內的元素
            printNode(root);
            System.out.println();
        }
        if (root == null) {
            return;
        }

        //打印子節點的元素
        if (root.getNodes() != null) {
            //找到最左邊的節點
            Node leftNode = null;
            Node tmpNode = null;
            List<Node> childNodes = root.getNodes();
            for (Node node : childNodes) {
                if (node.getPreviousNode() == null) {
                    leftNode = node;
                    tmpNode = node;
                }
            }

            while (leftNode != null) {
                //從最左邊的節點向右打印
                printNode(leftNode);
                System.out.print("|");
                leftNode = leftNode.getNextNode();
            }
            System.out.println();
            printBtree(tmpNode);
        }
    }

    //打印一個節點內的元素
    private void printNode(Node node) {
        List<KeyAndValue> keyAndValues = node.getKeyAndValue();
        for (int i = 0; i < keyAndValues.size(); i++) {
            if (i != (keyAndValues.size() - 1)) {
                System.out.print(keyAndValues.get(i).getKey() + ",");
            } else {
                System.out.print(keyAndValues.get(i).getKey());
            }
        }
    }

    public Object search(int key, Node node, String mode) {

        //如果是葉子節點則直接取值
        if (node.isLeaf()) {
            List<KeyAndValue> keyAndValues = node.getKeyAndValue();
            for (KeyAndValue keyAndValue : keyAndValues) {
                if (keyAndValue.getKey() == key) {
                    switch (mode) {
                        case NODE:
                            return node;
                        case INT:
                            return keyAndValue.getValue();
                    }
                }
            }
            return null;
        }


        List<Node> nodes = node.getNodes();
        //如果尋找的key小於節點的鍵的最小值
        int minKey = node.getKeyAndValue().get(0).getKey();
        if (key < minKey) {
            for (Node n : nodes) {
                List<KeyAndValue> keyAndValues = n.getKeyAndValue();
                //找到子節點集合中最大鍵小於父節點最小鍵節點
                if (keyAndValues.get(keyAndValues.size() - 1).getKey() < minKey) {
                    return search(key, n, mode);
                }
            }
        }
        //如果尋找的key大於節點的鍵的最大值
        int maxKey = getMaxKeyInNode(node);
        if (key >= maxKey) {
            for (Node n : nodes) {
                List<KeyAndValue> keyAndValues = n.getKeyAndValue();
                //找到子節點集合中最小鍵大於等於父節點最小大鍵節點
                if (keyAndValues.get(0).getKey() >= maxKey) {
                    return search(key, n, mode);
                }
            }
        }

        //如果尋找的key在最大值和最小值之間，首先定位到最窄的區間
        int min = getLeftBoundOfKey(node, key);
        int max = getRightBoundOfKey(node, key);


        //去所有的子節點中找鍵的范圍在min和max之間的節點
        for (Node n : nodes) {
            List<KeyAndValue> kvs = n.getKeyAndValue();
            //找到子節點集合中鍵的范圍在min和max之間的節點
            if (kvs.get(0).getKey() >= min && kvs.get(kvs.size() - 1).getKey() < max) {
                return search(key, n, mode);
            }
        }
        return null;
    }


    public boolean delete(int key) {
        System.out.println("delete:" + key);
        System.out.println();

        //首先找到要刪除的key所在的節點
        Node deleteNode = (Node) search(key, root, NODE);
        //如果沒找到則刪除失敗
        if (deleteNode == null) {
            return false;
        }

        if (deleteNode == root) {
            delKeyAndValue(root.getKeyAndValue(), key);
            return true;
        }

        if (deleteNode == head && isNeedMerge(head)) {
            head = head.getNextNode();
        }

        return merge(deleteNode, key);
    }


    //平衡當前節點和前節點或者后節點的數量，使兩者的數量都滿足條件
    private boolean balanceNode(Node node, Node bratherNode, String nodeType) {
        if (bratherNode == null) {
            return false;
        }
        List<KeyAndValue> delKeyAndValues = node.getKeyAndValue();
        if (isMoreElement(bratherNode)) {
            List<KeyAndValue> bratherKeyAndValues = bratherNode.getKeyAndValue();
            int bratherSize = bratherKeyAndValues.size();
            //兄弟節點刪除挪走的鍵值對
            KeyAndValue keyAndValue = null;
            KeyAndValue keyAndValue1;
            switch (nodeType) {
                case PRENODE:
                    keyAndValue = bratherKeyAndValues.remove(bratherSize - 1);
                    keyAndValue1 = getKeyAndValueinMinAndMax(node.getParantNode(), keyAndValue.getKey(), getMinKeyInNode(node));
                    keyAndValue1.setKey(keyAndValue.getKey());
                    break;
                case NEXTNODE:
                    keyAndValue = bratherKeyAndValues.remove(0);
                    keyAndValue1 = getKeyAndValueinMinAndMax(node.getParantNode(), getMaxKeyInNode(node), keyAndValue.getKey());
                    keyAndValue1.setKey(bratherKeyAndValues.get(0).getKey());
                    break;
            }
            //當前節點添加從前一個節點得來的鍵值對
            delKeyAndValues.add(keyAndValue);

            //對鍵值對重排序
            Collections.sort(delKeyAndValues);
            return true;
        }
        return false;
    }

    public boolean merge(Node node, int key) {
        List<KeyAndValue> delKeyAndValues = node.getKeyAndValue();
        //首先刪除該key-vaule
        delKeyAndValue(delKeyAndValues, key);
        //如果要刪除的節點的鍵值對的數目小於節點最大鍵值對數目*填充因子
        if (isNeedMerge(node)) {
            Boolean isBalance;
            //如果左節點有富余的鍵值對，則取一個到當前節點
            Node preNode = getPreviousNode(node);
            isBalance = balanceNode(node, preNode, PRENODE);
            //如果此時已經平衡，則已經刪除成功
            if (isBalance) return true;

            //如果右兄弟節點有富余的鍵值對，則取一個到當前節點
            Node nextNode = getNextNode(node);
            isBalance = balanceNode(node, nextNode, NEXTNODE);

            return isBalance || mergeNode(node, key);
        } else {
            return true;
        }
    }

    //合並節點
    //key 待刪除的key
    private boolean mergeNode(Node node, int key) {
        if (node.isRoot()) {
            return false;
        }
        Node preNode;
        Node nextNode;
        Node parentNode = node.getParantNode();
        List<Node> childNodes = parentNode.getNodes();
        List<Node> childNodes1 = node.getNodes();
        List<KeyAndValue> parentKeyAndValue = parentNode.getKeyAndValue();
        List<KeyAndValue> keyAndValues = node.getKeyAndValue();

        if (node.isLeaf()) {
            if (parentKeyAndValue.size() == 1 && parentNode != root) {
                return true;
            }
            preNode = getPreviousNode(node);
            nextNode = getNextNode(node);
            if (preNode != null) {
                List<KeyAndValue> preKeyAndValues = preNode.getKeyAndValue();
                keyAndValues.addAll(preKeyAndValues);
                if (preNode.isHead()) {
                    head = node;
                    node.setPreviousNode(null);
                } else {
                    preNode.getPreviousNode().setNextNode(node);
                    node.setPreviousNode(preNode.getPreviousNode());
                }
                //將合並后節點的后節點設置為當前節點的后節點
                preNode.setNextNode(node.getNextNode());
                KeyAndValue keyAndValue = getKeyAndValueinMinAndMax(parentNode, getMinKeyInNode(preNode), key);
                delKeyAndValue(parentKeyAndValue, keyAndValue.getKey());
                if (parentKeyAndValue.isEmpty()) {
                    root = node;
                } else {
                    //刪除當前節點
                    childNodes.remove(preNode);
                }
                Collections.sort(keyAndValues);
                merge(parentNode, key);
                return true;
            }

            if (nextNode != null) {
                List<KeyAndValue> nextKeyAndValues = nextNode.getKeyAndValue();
                keyAndValues.addAll(nextKeyAndValues);
                if (nextNode.isTail()) {
                    node.setPreviousNode(null);
                } else {
                    nextNode.getNextNode().setPreviousNode(node);
                    node.setNextNode(nextNode.getNextNode());
                }

                KeyAndValue keyAndValue = getKeyAndValueinMinAndMax(parentNode, key, getMinKeyInNode(nextNode));
                delKeyAndValue(parentKeyAndValue, keyAndValue.getKey());
                if (parentKeyAndValue.isEmpty()) {
                    root = node;
                    node.setParantNode(null);
                } else {
                    //刪除當前節點
                    childNodes.remove(nextNode);
                }
                Collections.sort(keyAndValues);
                merge(parentNode, key);
                return true;
            }
            //前節點和后節點都等於null那么是root節點
            return false;
        } else {
            preNode = getPreviousNode(node);
            nextNode = getNextNode(node);
            if (preNode != null) {
                //將前一個節點和當前節點還有父節點中的相應Key-value合並
                List<KeyAndValue> preKeyAndValues = preNode.getKeyAndValue();
                preKeyAndValues.addAll(keyAndValues);
                int min = getMaxKeyInNode(preNode);
                int max = getMinKeyInNode(node);
                //父節點中移除這個key-value
                KeyAndValue keyAndValue = getKeyAndValueinMinAndMax(parentNode, min, max);
                parentKeyAndValue.remove(keyAndValue);
                if (parentKeyAndValue.isEmpty()) {
                    root = preNode;
                    node.setParantNode(null);
                    preNode.setParantNode(null);
                } else {
                    childNodes.remove(node);
                }
                assert nextNode != null;
                preNode.setNextNode(nextNode.getNextNode());
                //前節點加上一個當前節點的所有子節點中最小key的key-value
                KeyAndValue minKeyAndValue = getMinKeyAndValueInChildNode(node);
                assert minKeyAndValue != null;
                KeyAndValue keyAndValue1 = new KeyAndValue(minKeyAndValue.getKey(), minKeyAndValue.getValue());
                preKeyAndValues.add(keyAndValue1);
                List<Node> preChildNodes = preNode.getNodes();
                preChildNodes.addAll(node.getNodes());
                //將當前節點的孩子節點的父節點設為當前節點的后節點
                for (Node node1 : childNodes1) {
                    node1.setParantNode(preNode);
                }
                Collections.sort(preKeyAndValues);
                merge(parentNode, key);
                return true;
            }

            if (nextNode != null) {
                //將后一個節點和當前節點還有父節點中的相應Key-value合並
                List<KeyAndValue> nextKeyAndValues = nextNode.getKeyAndValue();
                nextKeyAndValues.addAll(keyAndValues);

                int min = getMaxKeyInNode(node);
                int max = getMinKeyInNode(nextNode);
                //父節點中移除這個key-value
                KeyAndValue keyAndValue = getKeyAndValueinMinAndMax(parentNode, min, max);
                parentKeyAndValue.remove(keyAndValue);
                childNodes.remove(node);
                if (parentKeyAndValue.isEmpty()) {
                    root = nextNode;
                    nextNode.setParantNode(null);
                } else {
                    childNodes.remove(node);
                }
                nextNode.setPreviousNode(node.getPreviousNode());
                //后節點加上一個當后節點的所有子節點中最小key的key-value
                KeyAndValue minKeyAndValue = getMinKeyAndValueInChildNode(nextNode);
                assert minKeyAndValue != null;
                KeyAndValue keyAndValue1 = new KeyAndValue(minKeyAndValue.getKey(), minKeyAndValue.getValue());
                nextKeyAndValues.add(keyAndValue1);
                List<Node> nextChildNodes = nextNode.getNodes();
                nextChildNodes.addAll(node.getNodes());
                //將當前節點的孩子節點的父節點設為當前節點的后節點
                for (Node node1 : childNodes1) {
                    node1.setParantNode(nextNode);
                }
                Collections.sort(nextKeyAndValues);
                merge(parentNode, key);
                return true;
            }
            return false;
        }
    }

    //得到當前節點的前節點
    private Node getPreviousNode(Node node) {
        if (node.isRoot()) {
            return null;
        }

        Node parentNode = node.getParantNode();
        //得到兄弟節點
        List<Node> nodes = parentNode.getNodes();
        List<KeyAndValue> keyAndValues = new ArrayList<>();
        for (Node n : nodes) {
            List<KeyAndValue> list = n.getKeyAndValue();
            int maxKeyAndValue = list.get(list.size() - 1).getKey();
            if (maxKeyAndValue < getMinKeyInNode(node)) {
                keyAndValues.add(new KeyAndValue(maxKeyAndValue, n));
            }
        }
        Collections.sort(keyAndValues);
        if (keyAndValues.isEmpty()) {
            return null;
        }
        return (Node) keyAndValues.get(keyAndValues.size() - 1).getValue();
    }


    //得到當前節點的后節點
    private Node getNextNode(Node node) {
        if (node.isRoot()) {
            return null;
        }

        Node parentNode = node.getParantNode();
        //得到兄弟節點
        List<Node> nodes = parentNode.getNodes();
        List<KeyAndValue> keyAndValues = new ArrayList<>();
        for (Node n : nodes) {
            List<KeyAndValue> list = n.getKeyAndValue();
            int minKeyAndValue = list.get(0).getKey();
            if (minKeyAndValue > getMaxKeyInNode(node)) {
                keyAndValues.add(new KeyAndValue(minKeyAndValue, n));
            }
        }
        Collections.sort(keyAndValues);
        if (keyAndValues.isEmpty()) {
            return null;
        }
        return (Node) keyAndValues.get(0).getValue();
    }


    private int getMinKeyInNode(Node node) {
        List<KeyAndValue> keyAndValues = node.getKeyAndValue();
        return keyAndValues.get(0).getKey();
    }

    private int getMaxKeyInNode(Node node) {
        List<KeyAndValue> keyAndValues = node.getKeyAndValue();
        return keyAndValues.get(keyAndValues.size() - 1).getKey();
    }


    private int getLeftBoundOfKey(Node node, int key) {
        int left = 0;
        List<KeyAndValue> keyAndValues = node.getKeyAndValue();
        for (int i = 0; i < keyAndValues.size(); i++) {
            if (keyAndValues.get(i).getKey() <= key && keyAndValues.get(i + 1).getKey() > key) {
                left = keyAndValues.get(i).getKey();
                break;
            }
        }
        return left;
    }

    private int getRightBoundOfKey(Node node, int key) {
        int right = 0;
        List<KeyAndValue> keyAndValues = node.getKeyAndValue();
        for (int i = 0; i < keyAndValues.size(); i++) {
            if (keyAndValues.get(i).getKey() <= key && keyAndValues.get(i + 1).getKey() > key) {
                right = keyAndValues.get(i + 1).getKey();
                break;
            }
        }
        return right;
    }


    private void delKeyAndValue(List<KeyAndValue> keyAndValues, int key) {
        for (KeyAndValue keyAndValue : keyAndValues) {
            if (keyAndValue.getKey() == key) {
                keyAndValues.remove(keyAndValue);
                break;
            }
        }
    }

    //找到node的鍵值對中在min和max中的鍵值對
    private KeyAndValue getKeyAndValueinMinAndMax(Node node, int min, int max) {
        if (node == null) {
            return null;
        }
        List<KeyAndValue> keyAndValues = node.getKeyAndValue();
        KeyAndValue keyAndValue = null;
        for (KeyAndValue k : keyAndValues) {
            if (k.getKey() > min && k.getKey() <= max) {
                keyAndValue = k;
                break;
            }
        }
        return keyAndValue;
    }

//    private KeyAndValue getMaxKeyAndValueInChildNode(Node node) {
//        if (node.getNodes() == null || node.getNodes().isEmpty()) {
//            return null;
//        }
//        List<KeyAndValue> sortKeyAndValues = new ArrayList<>();
//        List<Node> childNodes = node.getNodes();
//        for (Node childNode : childNodes) {
//            List<KeyAndValue> keyAndValues = childNode.getKeyAndValue();
//            KeyAndValue maxKeyAndValue = keyAndValues.get(keyAndValues.size() - 1);
//            sortKeyAndValues.add(maxKeyAndValue);
//        }
//        Collections.sort(sortKeyAndValues);
//        return sortKeyAndValues.get(sortKeyAndValues.size() - 1);
//    }

    private KeyAndValue getMinKeyAndValueInChildNode(Node node) {
        if (node.getNodes() == null || node.getNodes().isEmpty()) {
            return null;
        }
        List<KeyAndValue> sortKeyAndValues = new ArrayList<>();
        List<Node> childNodes = node.getNodes();
        for (Node childNode : childNodes) {
            List<KeyAndValue> keyAndValues = childNode.getKeyAndValue();
            KeyAndValue minKeyAndValue = keyAndValues.get(0);
            sortKeyAndValues.add(minKeyAndValue);
        }
        Collections.sort(sortKeyAndValues);
        return sortKeyAndValues.get(0);
    }

    private boolean isNeedMerge(Node node) {
        if (node == null) {
            return false;
        }
        List<KeyAndValue> keyAndValues = node.getKeyAndValue();
        return keyAndValues.size() < rank / 2;
    }

    //判斷一個節點是否有富余的鍵值對
    private boolean isMoreElement(Node node) {
        return node != null && (node.getKeyAndValue().size() > rank / 2);
    }
}

　　測試代碼：

public class Main {

    public static void main(String[] args) {
        Btree btree = new Btree(4 );
        KeyAndValue keyAndValue = new KeyAndValue(1,"123");
        KeyAndValue keyAndValue1 = new KeyAndValue(2,"123");
        KeyAndValue keyAndValue2 = new KeyAndValue(3,"123");
        KeyAndValue keyAndValue3 = new KeyAndValue(4,"123");
        KeyAndValue keyAndValue4 = new KeyAndValue(5,"123");
        KeyAndValue keyAndValue5 = new KeyAndValue(6,"123");
        KeyAndValue keyAndValue6 = new KeyAndValue(7,"12300");
        KeyAndValue keyAndValue7 = new KeyAndValue(8,"546");
        KeyAndValue keyAndValue8 = new KeyAndValue(9,"123");
        KeyAndValue keyAndValue9 = new KeyAndValue(10,"123");
        KeyAndValue keyAndValue10 = new KeyAndValue(11,"123");
        KeyAndValue keyAndValue11 = new KeyAndValue(12,"123");
        KeyAndValue keyAndValue12 = new KeyAndValue(13,"123");
        KeyAndValue keyAndValue14 = new KeyAndValue(15,"12345");
        KeyAndValue keyAndValue15 = new KeyAndValue(16,"12345");
        KeyAndValue keyAndValue16 = new KeyAndValue(17,"12345");
        KeyAndValue keyAndValue17 = new KeyAndValue(18,"12345");
        KeyAndValue keyAndValue18 = new KeyAndValue(19,"12345");
        KeyAndValue keyAndValue19 = new KeyAndValue(20,"12345");
        KeyAndValue keyAndValue20 = new KeyAndValue(21,"12345");

        btree.insert(keyAndValue);
        btree.insert(keyAndValue5);
        btree.insert(keyAndValue9);
        btree.insert(keyAndValue1);
        btree.insert(keyAndValue7);
        btree.insert(keyAndValue10);
        btree.insert(keyAndValue17);
        btree.insert(keyAndValue2);
        btree.insert(keyAndValue14);
        btree.insert(keyAndValue16);
        btree.insert(keyAndValue11);
        btree.insert(keyAndValue12);
        btree.insert(keyAndValue3);
        btree.insert(keyAndValue8);
        btree.insert(keyAndValue18);
        btree.insert(keyAndValue15);
        btree.insert(keyAndValue4);
        btree.insert(keyAndValue19);
        btree.insert(keyAndValue6);
        btree.insert(keyAndValue20);


        btree.printBtree(btree.getRoot());

        btree.delete(1);
        btree.printBtree(btree.getRoot());

        btree.delete(0);
        btree.printBtree(btree.getRoot());

        btree.delete(2);
        btree.printBtree(btree.getRoot());

        btree.delete(11);
        btree.printBtree(btree.getRoot());

        btree.delete(3);
        btree.printBtree(btree.getRoot());

        btree.delete(4);
        btree.printBtree(btree.getRoot());

        btree.delete(5);
        btree.printBtree(btree.getRoot());

        btree.delete(9);
        btree.printBtree(btree.getRoot());

        btree.delete(6);
        btree.printBtree(btree.getRoot());

        btree.delete(13);
        btree.printBtree(btree.getRoot());

        btree.delete(7);
        btree.printBtree(btree.getRoot());

        btree.delete(10);
        btree.printBtree(btree.getRoot());

        btree.delete(18);
        btree.printBtree(btree.getRoot());

        btree.delete(8);
        btree.printBtree(btree.getRoot());

        btree.delete(12);
        btree.printBtree(btree.getRoot());

        btree.delete(20);
        btree.printBtree(btree.getRoot());

        btree.delete(19);
        btree.printBtree(btree.getRoot());

        btree.delete(15);
        btree.printBtree(btree.getRoot());

        btree.delete(17);
        btree.printBtree(btree.getRoot());


        
    }
}

　　測試結果：

8,12
3,6|10|15,18,20|
1,2|3,4,5|6,7|8,9|10,11|12,13|15,16,17|18,19|20,21|
delete:1

8,12
4,6|10|15,18,20|
2,3|4,5|6,7|8,9|10,11|12,13|15,16,17|18,19|20,21|
delete:0

8,12
4,6|10|15,18,20|
2,3|4,5|6,7|8,9|10,11|12,13|15,16,17|18,19|20,21|
delete:2

12
6,8,10|15,18,20|
3,4,5|6,7|8,9|10,11|12,13|15,16,17|18,19|20,21|
delete:11

12
6,8|15,18,20|
3,4,5|6,7|8,9,10|12,13|15,16,17|18,19|20,21|
delete:3

12
6,8|15,18,20|
4,5|6,7|8,9,10|12,13|15,16,17|18,19|20,21|
delete:4

18
8,15|18,20|
5,6,7|8,9,10|12,13|15,16,17|18,19|20,21|
delete:5

18
8,15|18,20|
6,7|8,9,10|12,13|15,16,17|18,19|20,21|
delete:9

18
8,15|18,20|
6,7|8,10|12,13|15,16,17|18,19|20,21|
delete:6

12,15,18,20
7,8,10|12,13|15,16,17|18,19|20,21|
delete:13

10,15,18,20
7,8|10,12|15,16,17|18,19|20,21|
delete:7

15,18,20
8,10,12|15,16,17|18,19|20,21|
delete:10

15,18,20
8,12|15,16,17|18,19|20,21|
delete:18

15,17,20
8,12|15,16|17,19|20,21|
delete:8

17,20
12,15,16|17,19|20,21|
delete:12

17,20
15,16|17,19|20,21|
delete:20

17
15,16|17,19,21|
delete:19

17
15,16|17,21|
delete:15

16,17,21
delete:17

16,21