b+树

Author: beston123

src/main/java/code/collection/tree/btree/BPlusTree.java

@@ -0,0 +1,290 @@
+package code.collection.tree.btree;
+
+import com.google.common.collect.Lists;
+import org.apache.commons.lang3.tuple.Pair;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * 〈B+树〉<p>
+ * 〈功能详细描述〉
+ *
+ * @author zixiao
+ * @date 2019/12/20
+ * @see https://blog.csdn.net/Fmuma/article/details/80287924
+ */
+public class BPlusTree {
+
+    private TreeNode root;
+
+    public static int m = 5;
+
+    public BPlusTree(int m) {
+        BPlusTree.m = m;
+    }
+
+    public BPlusTree() {
+        this(5);
+    }
+
+    public boolean insert(int key, long dataAddr) {
+        LeafNode leaf = null;
+        List<IndexNode> parents = null;
+        if (root == null) {
+            leaf = new LeafNode();
+            root = leaf;
+            parents = Collections.EMPTY_LIST;
+        } else {
+            Pair<LeafNode, List<IndexNode>> pair = findLeaf(key);
+            leaf = pair.getKey();
+            parents = pair.getRight();
+        }
+        TreeNode highNode = insertLeaf(parents, leaf, key, dataAddr);
+        if (highNode != null) {
+            root = highNode;
+        }
+        return true;
+    }
+
+    /**
+     * 插入数据到叶子
+     *
+     * @param parents
+     * @param leaf
+     * @param key
+     * @param dataAddr
+     * @return 新生成的最高节点
+     */
+    private TreeNode insertLeaf(List<IndexNode> parents, LeafNode leaf, int key, long dataAddr) {
+        leaf.insert(key, dataAddr);
+        if (leaf.keySize() < leaf.m()) {
+            return null;
+        }
+        // 若当前结点key的个数小于等于m-1，叶子结点分裂成左右两个叶子结点
+        return split(parents, leaf);
+    }
+
+    /**
+     * 节点node分裂
+     *
+     * @param parents
+     * @param node
+     * @return
+     */
+    private TreeNode split(List<IndexNode> parents, TreeNode node) {
+        Pair<TreeNode, Integer> pair = node.split();
+        TreeNode node2 = pair.getKey();
+        int newIndexKey = pair.getValue();
+
+        if (parents.isEmpty()) {
+            return new IndexNode(newIndexKey, node, node2);
+        }
+        return insertIndex(parents.subList(1, parents.size()), parents.get(0), newIndexKey, node, node2);
+    }
+
+    /**
+     * 插入key到索引节点
+     *
+     * @param parents
+     * @param node
+     * @param key
+     * @param left
+     * @param right
+     * @return 新生成的最高节点
+     */
+    private TreeNode insertIndex(List<IndexNode> parents, IndexNode node, int key, TreeNode left, TreeNode right) {
+        node.insert(key, left, right);
+        if (node.keySize() < node.m()) {
+            return null;
+        }
+        // 若当前结点key的个数小于等于m-1，索引结点分裂成左右两个索引结点
+        return split(parents, node);
+    }
+
+    /**
+     * 查找叶关键字对应的叶子节点，及索引父节点
+     *
+     * @param key
+     * @return
+     */
+    private Pair<LeafNode, List<IndexNode>> findLeaf(int key) {
+        TreeNode node = root;
+        List<IndexNode> parents = new ArrayList<>();
+        while (!node.isLeaf()) {
+            parents.add((IndexNode) node);
+            node = ((IndexNode) node).findChild(key);
+        }
+        Collections.reverse(parents);
+        return Pair.of((LeafNode) node, parents);
+    }
+
+    public Long get(int key) {
+        LeafNode node = findLeafNode(key);
+        for (int i = 0; i < node.keySize(); i++) {
+            if (node.keys()[i].equals(key)) {
+                return node.getDataAddr()[i];
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 查找叶关键字对应的叶子节点
+     *
+     * @param key
+     * @return
+     */
+    private LeafNode findLeafNode(int key) {
+        TreeNode node = root;
+        while (!node.isLeaf()) {
+            node = ((IndexNode) node).findChild(key);
+        }
+        return (LeafNode) node;
+    }
+
+    public List<Long> range(int fromKey, int toKey) {
+        List<Long> dataList = new ArrayList<>();
+        LeafNode from = findLeafNode(fromKey);
+        LeafNode to = null;
+        Integer fromLast = from.keys[from.keySize - 1];
+
+        //1 数据在一个节点上
+        if (fromLast > toKey || (to = findLeafNode(toKey)) == from) {
+            for (int i = 0; i < from.keySize; i++) {
+                if (from.keys[i] >= fromKey && from.keys[i] <= toKey) {
+                    dataList.add(from.getDataAddr()[i]);
+                }
+            }
+            return dataList;
+        }
+
+        //2 数据分布在多个节点上
+        LeafNode node = from;
+        while (node != null) {
+            if (node != from && node != to) {
+                //a 既不是开始又不是结束节点，则所有数据都加上
+                for (int i = 0; i < node.keySize; i++) {
+                    dataList.add(node.getDataAddr()[i]);
+                }
+            } else if (node == from) {
+                //b 开始节点，只取大于fromKey的数据
+                for (int i = 0; i < node.keySize; i++) {
+                    if (node.keys[i] >= fromKey) {
+                        dataList.add(node.getDataAddr()[i]);
+                    }
+                }
+            } else if (node == to) {
+                //c 结束节点，只取小于toKey的数据
+                for (int i = 0; i < node.keySize; i++) {
+                    if (node.keys[i] <= toKey) {
+                        dataList.add(node.getDataAddr()[i]);
+                    }
+                }
+                break;
+            }
+            node = node.getNext();
+        }
+        return dataList;
+    }
+
+    public void print() {
+        StringBuilder sb = new StringBuilder();
+        append(sb, Lists.newArrayList(root));
+        System.out.println(sb);
+    }
+
+    private void append(StringBuilder sb, List<TreeNode> nodeList) {
+        List<TreeNode> children = new ArrayList<>();
+        for (TreeNode node : nodeList) {
+            if (node == null) {
+                continue;
+            } else if (node.isLeaf()) {
+                sb.append("[");
+                joinKeys(sb, ",", node.keys());
+                sb.append("]").append("->");
+            } else {
+                children.addAll(Lists.newArrayList(((IndexNode) node).children()));
+                sb.append("[");
+                joinKeys(sb, " ", node.keys());
+                sb.append("]");
+                sb.append("\t");
+            }
+        }
+        sb.append("\n\r");
+        if (!children.isEmpty()) {
+            append(sb, children);
+        }
+    }
+
+    private void joinKeys(StringBuilder sb, CharSequence delimiter, Integer[] keys) {
+        boolean first = true;
+        for (Integer key : keys) {
+            if (key == null) {
+                break;
+            }
+            if (first) {
+                first = false;
+            } else {
+                sb.append(delimiter);
+            }
+            sb.append(key);
+        }
+    }
+
+    public static void main(String[] args) {
+        BPlusTree bPlusTree = new BPlusTree(5);
+        /**
+         * m=5
+         *   				  [11]
+         *      [7      9]              [13       15]
+         * [5,6]->[7,8]->[9,10]->[11,12]->[13,14]->[15,16,17]
+         */
+        bPlusTree.insert(5, 1);
+        bPlusTree.insert(6, 2);
+        bPlusTree.insert(7, 3);
+        bPlusTree.insert(8, 4);
+        bPlusTree.insert(9, 5);
+        bPlusTree.insert(10, 6);
+        bPlusTree.insert(11, 7);
+        bPlusTree.insert(12, 8);
+        bPlusTree.insert(13, 9);
+        bPlusTree.insert(14, 10);
+        bPlusTree.insert(15, 11);
+        bPlusTree.insert(16, 12);
+        bPlusTree.insert(17, 13);
+        bPlusTree.print();
+
+        /**
+         * 				          [11            ,           17]
+         * 		  [7,   9,]		           [13,     15]               [19,     21]
+         *   [5,6]->[7,8] ->[9,10]->[11,12]->[13,14]->[15,16]->[17,18]->[19,20]->[21,22,23]
+         */
+        bPlusTree.insert(18, 14);
+        bPlusTree.insert(19, 15);
+        bPlusTree.insert(20, 16);
+        bPlusTree.insert(21, 17);
+        bPlusTree.insert(22, 18);
+        bPlusTree.insert(23, 19);
+        bPlusTree.print();
+
+        System.out.println("Get key " + 4 + ": " + bPlusTree.get(4));
+        System.out.println("Get key " + 9 + ": " + bPlusTree.get(9));
+        System.out.println("Get key " + 23 + ": " + bPlusTree.get(23));
+
+        System.out.print("Range key [" + 5 + ", " + 6 + "]: ");
+        bPlusTree.range(5, 6).forEach(l -> {
+            System.out.print(l + " ");
+        });
+        System.out.println();
+
+        System.out.print("Range key [" + 10 + ", " + 13 + "]: ");
+        bPlusTree.range(10, 13).forEach(l -> {
+            System.out.print(l + " ");
+        });
+        System.out.println();
+
+    }
+
+}

src/main/java/code/collection/tree/btree/IndexNode.java

@@ -0,0 +1,93 @@
+package code.collection.tree.btree;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+/**
+ * 非叶子节点，索引节点
+ * 假设keywords=[3, 5, 8, 10]
+ * 4个键值将数据分为5个区间:(-INF,3), [3,5), [5,8), [8,10), [10,INF)
+ * 5个区间分别对应:children[0]...children[4]
+ * m值是事先计算得到的，计算的依据是让所有信息的大小正好等于页的大小:
+ * PAGE_SIZE = (m-1)*4*[keywords大小] + m*8*[children大小]
+ *
+ * @author zixiao
+ * @date 2019/12/20
+ */
+public class IndexNode extends TreeNode {
+
+    /**
+     * 保存子节点指针
+     */
+    private TreeNode[] children;
+
+    public IndexNode() {
+        keys = new Integer[m];
+        children = new TreeNode[m+1];
+    }
+
+    public IndexNode(int key, TreeNode left, TreeNode right) {
+        this();
+        insert(key, left, right);
+    }
+
+    public TreeNode[] children(){
+        return children;
+    }
+
+    public TreeNode findChild(int key){
+        for (int i = 0; i < keySize; i++) {
+            if(key < keys[i]){
+                return children[i];
+            }else if(key == keys[i]){
+                return children[i+1];
+            }
+        }
+        return children[keySize];
+    }
+
+    public boolean insert(int key, TreeNode left, TreeNode right){
+        keys[keySize] = key;
+        children[keySize] = left;
+        children[keySize+1] = right;
+        keySize++;
+        return true;
+    }
+
+    public boolean delete(int idx){
+        keys[idx] = null;
+        children[idx+1] = null;
+        keySize--;
+        return true;
+    }
+
+    /**
+     * 将这个索引类型结点分裂成两个索引结点，
+     * 以中间位置的key划分两半，左索引结点包含一半key，右索引结点包后一半的key，
+     * 将中间位置的key进位到父结点中， 并把进位节点的左孩子指向左结点, 进位到父结点的key右孩子指向右结点。
+     * 将当前结点的指针指向父结点，然后重复本步骤。
+     * m=5
+     * 0 1 2 3 4
+     * 左索引结点：0， 1； 右索引结点 3，4； 2进位到父节点
+     *
+     * @return
+     */
+    public Pair<TreeNode, Integer> split(){
+        IndexNode newNode = new IndexNode();
+        //提取中间节点的key
+        int indexKey = keys[m/2];
+        //从中间节点后一个节点开始拷贝
+        for (int i = m/2 + 1; i < keys.length; i++) {
+            newNode.insert(keys[i], children[i], children[i+1]);
+        }
+        //从中间节点（包括）开始删除
+        for (int i = m/2; i < keys.length; i++) {
+            delete(i);
+        }
+        return Pair.of(newNode, indexKey);
+    }
+
+    @Override
+    public boolean isLeaf() {
+        return false;
+    }
+}