粗略模拟B+树的构建和查询

最新推荐文章于 2024-06-10 13:00:48 发布
最新推荐文章于 2024-06-10 13:00:48 发布
阅读量132 收藏
点赞数
文章标签： b树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w820896059/article/details/132367526
版权 
package com.qixian.general.controller;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.qixian.general.dao.HardRecordDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.util.*;


@RestController
@RequestMapping("/apiqixian/BPlusTree")
public class BPlusTree {


    @Autowired
    private HardRecordDao hardRecordDao;

    //ID主键索引树
    static List<JSONObject> root = new ArrayList<JSONObject>();
    //联合索引字段B+树
    static List<JSONObject> joinTree = new ArrayList<JSONObject>();


    //从下往上构建联合索引树
    @GetMapping("/createBPlusTreeByIndexVocabularyAndGradationAndLastCreatedTimeAndDisabled")
    public List<JSONObject> createBPlusTreeByIndexVocabularyAndGradationAndLastCreatedTimeAndDisabled(HttpServletRequest request) throws InterruptedException {

        List<JSONObject> jsonObjects = hardRecordDao.listBy(new HashMap<String, Object>());
        List<JSONObject> jsonObjects1 = new ArrayList<JSONObject>();
        //选取联合查询字段和ID进集合
        for (int i = 0; i < jsonObjects.size(); i++) {

            JSONObject item = new JSONObject();
            item.put("indexVocabulary", jsonObjects.get(i).getString("indexVocabulary"));
            item.put("gradation", jsonObjects.get(i).getInteger("gradation"));
            item.put("lastCreatedTime", jsonObjects.get(i).getLong("lastCreatedTime"));
            item.put("disabled", jsonObjects.get(i).getInteger("disabled"));
            item.put("id", jsonObjects.get(i).getInteger("id"));
            jsonObjects1.add(item);
        }

        //冒泡排序，按照indexVocabulary从小到大排序
        for (int i = 0; i < jsonObjects1.size(); i++) {

            for (int j = 0; j < jsonObjects1.size() - i - 1; j++) {
                //从上往下相邻比对，重的往下沉
                if (Integer.parseInt(jsonObjects1.get(j).getString("indexVocabulary")) > Integer.parseInt(jsonObjects1.get(j + 1).getString("indexVocabulary"))) {
                    JSONObject jsonObject = jsonObjects1.get(j + 1);
                    jsonObjects1.set(j + 1, jsonObjects1.get(j));
                    jsonObjects1.set(j, jsonObject);

                }
            }
        }
        //冒泡排序，indexVocabulary相等的情况下根据gradation从小到大排序
        for (int i = 0; i < jsonObjects1.size(); i++) {

            for (int j = 0; j < jsonObjects1.size() - i - 1; j++) {
                if (jsonObjects1.get(j).getString("indexVocabulary").equals(jsonObjects1.get(j + 1).getString("indexVocabulary")) && jsonObjects1.get(j).getInteger("gradation") > jsonObjects1.get(j + 1).getInteger("gradation")) {
                    JSONObject jsonObject = jsonObjects1.get(j + 1);
                    jsonObjects1.set(j + 1, jsonObjects1.get(j));
                    jsonObjects1.set(j, jsonObject);

                }
            }
        }
        //冒泡排序，gradation相等的情况下根据lastCreatedTime从小到大排序
        for (int i = 0; i < jsonObjects1.size(); i++) {

            for (int j = 0; j < jsonObjects1.size() - i - 1; j++) {
                if (jsonObjects1.get(j).getInteger("gradation") == jsonObjects1.get(j + 1).getInteger("gradation") && jsonObjects1.get(j).getLong("lastCreatedTime") > jsonObjects1.get(j + 1).getLong("lastCreatedTime")) {
                    JSONObject jsonObject = jsonObjects1.get(j + 1);
                    jsonObjects1.set(j + 1, jsonObjects1.get(j));
                    jsonObjects1.set(j, jsonObject);

                }
            }
        }
        //冒泡排序，lastCreatedTime相等的情况下根据disabled从小到大排序
        for (int i = 0; i < jsonObjects1.size(); i++) {

            for (int j = 0; j < jsonObjects1.size() - i - 1; j++) {
                if (jsonObjects1.get(j).getInteger("disabled") > jsonObjects1.get(j + 1).getInteger("disabled") && jsonObjects1.get(j).getLong("lastCreatedTime") == jsonObjects1.get(j + 1).getLong("lastCreatedTime")) {
                    JSONObject jsonObject = jsonObjects1.get(j + 1);
                    jsonObjects1.set(j + 1, jsonObjects1.get(j));
                    jsonObjects1.set(j, jsonObject);

                }
            }
        }
        //给排好序的集合两两相邻元素互相配置pre字段指向前一个元素，next字段指向后一个元素
        for (int i = 0; i < jsonObjects1.size() - 1; i++) {
            jsonObjects1.get(i).put("next", jsonObjects1.get(i + 1));
            jsonObjects1.get(i + 1).put("pre", jsonObjects1.get(i));
        }
        //集合按照10个一组，计算总共有多少组
        int i1 = (int) Math.ceil((double) jsonObjects1.size() / 10);

        //第三层总集合
        List<JSONObject> threeListAll = new ArrayList<JSONObject>();
        //对集合进行每十个一组，所有的组装进threeListAll集合
        for (int i = 0; i < i1; i++) {
            JSONObject threeFloor = new JSONObject();
            List<JSONObject> leafList = new ArrayList<JSONObject>();
            for (int j = 0; j < 10; j++) {

                if (i * 10 + j < jsonObjects1.size()) {
                    //将每组第一个元素的联合索引字段保存进叶子元素作为该组各个字段的最小值代表
                    if (j == 0) {
                        threeFloor.put("indexVocabulary", jsonObjects1.get(i * 10 + j).getString("indexVocabulary"));
                        threeFloor.put("gradation", jsonObjects1.get(i * 10 + j).getInteger("gradation"));
                        threeFloor.put("lastCreatedTime", jsonObjects1.get(i * 10 + j).getLong("lastCreatedTime"));
                        threeFloor.put("disabled", jsonObjects1.get(i * 10 + j).getInteger("disabled"));
                    }
                    leafList.add(jsonObjects1.get(i * 10 + j));
                }
            }
            threeFloor.put("leafList", leafList);
            threeListAll.add(threeFloor);
        }


        //计算第三层按照每10个一组总共能分成多少组
        int i2 = (int) Math.ceil((double) threeListAll.size() / 10);

        //第二层所有分组的总集合
        List<JSONObject> secondListAll = new ArrayList<JSONObject>();
        //对集合进行每十个一组，所有的组装进secondListAll集合
        for (int i = 0; i < i2; i++) {
            JSONObject secondFloor = new JSONObject();
            List<JSONObject> threeList = new ArrayList<JSONObject>();
            for (int j = 0; j < 10; j++) {
                if (i * 10 + j < threeListAll.size()) {
                    //将每组第一个元素的联合索引字段保存进叶子元素作为该组各个字段的最小值代表
                    if (j == 0) {
                        secondFloor.put("indexVocabulary", threeListAll.get(i * 10 + j).getString("indexVocabulary"));
                        secondFloor.put("gradation", threeListAll.get(i * 10 + j).getInteger("gradation"));
                        secondFloor.put("lastCreatedTime", threeListAll.get(i * 10 + j).getLong("lastCreatedTime"));
                        secondFloor.put("disabled", threeListAll.get(i * 10 + j).getInteger("disabled"));
                    }
                    threeList.add(threeListAll.get(i * 10 + j));
                }
            }
            secondFloor.put("threeList", threeList);
            secondListAll.add(secondFloor);
        }

        //计算第二层按照每10个一组总共能分成多少组
        int i3 = (int) Math.ceil((double) secondListAll.size() / 10);
        //第一层所有分组的总集合
        List<JSONObject> firstListAll = new ArrayList<JSONObject>();
        //对集合进行每十个一组，所有的组装进firstListAll集合
        for (int i = 0; i < i3; i++) {
            JSONObject firstFloor = new JSONObject();
            List<JSONObject> secondList = new ArrayList<JSONObject>();
            for (int j = 0; j < 10; j++) {

                if (i * 10 + j < secondListAll.size()) {
                    //将每组第一个元素的联合索引字段保存进叶子元素作为该组各个字段的最小值代表
                    if (j == 0) {
                        firstFloor.put("indexVocabulary", secondListAll.get(i * 10 + j).getString("indexVocabulary"));
                        firstFloor.put("gradation", secondListAll.get(i * 10 + j).getInteger("gradation"));
                        firstFloor.put("lastCreatedTime", secondListAll.get(i * 10 + j).getLong("lastCreatedTime"));
                        firstFloor.put("disabled", secondListAll.get(i * 10 + j).getInteger("disabled"));
                    }
                    secondList.add(secondListAll.get(i * 10 + j));
                }
            }
            firstFloor.put("secondList", secondList);
            firstListAll.add(firstFloor);
        }
        //第一层所有分组的集合
        joinTree = firstListAll;
        return null;

    }


    //根据联合索引字段范围检索联合索引树
    @GetMapping("/getBPlusTreeWhere")
    public List<JSONObject> getBPlusTreeWhere(HttpServletRequest request, Integer minIndexVocabulary, Integer maxIndexVocabulary,
                                              Integer minGradation, Integer maxGradation, Long minLastCreatedTime, Long maxLastCreatedTime, Integer disabled) throws InterruptedException {

        int sumCount = 0;

        JSONArray target = null;
        //遍历联合索引树
        for (int i = 0; i < joinTree.size(); i++) {
            sumCount++;
            //如果第一层的当前分组的indexVocabulary最小值大于索引条件范围的最大值，那么说明符合条件的数据在上一个分组
            if (joinTree.get(i).getInteger("indexVocabulary") > maxIndexVocabulary) {
                //把上限的数据肯定在上一个分组，所以这里获取i-1
                target = joinTree.get(i - 1).getJSONArray("secondList");
                break;
            }
            //如果i == joinTree.size() - 1,说明遍历到第一层最后一个分组，依然没找到分组的最小值大于maxIndexVocabulary，那么说明maxIndexVocabulary存在在当前分组中（假设我们测试模拟的范围条件没有超出集合范围）
            if (i == joinTree.size() - 1) {
                target = joinTree.get(i).getJSONArray("secondList");
                break;
            }
        }

        //遍历第二层的分组
        for (int j = 0; j < target.size(); j++) {
            sumCount++;
            //如果第二层的当前分组的indexVocabulary最小值大于索引条件范围的最大值，那么说明符合条件的数据在上一个分组
            if (target.getJSONObject(j).getInteger("indexVocabulary") > maxIndexVocabulary) {
                target = target.getJSONObject(j - 1).getJSONArray("threeList");
                break;
            }
            //如果i == target.size() - 1,说明遍历到第一层最后一个分组，依然没找到分组的最小值大于maxIndexVocabulary，那么说明maxIndexVocabulary存在在当前分组中（假设我们测试模拟的范围条件没有超出集合范围）
            if (j == target.size() - 1) {
                target = target.getJSONObject(j).getJSONArray("threeList");
                break;
            }
        }
        //遍历第三层的分组
        for (int j = 0; j < target.size(); j++) {
            sumCount++;

            if (target.getJSONObject(j).getInteger("indexVocabulary") > maxIndexVocabulary) {
                target = target.getJSONObject(j - 1).getJSONArray("leafList");
                break;
            }
            if (j == target.size() - 1) {
                target = target.getJSONObject(j).getJSONArray("leafList");
                break;
            }
        }

        //遍历叶子结点的集合
        for (int i = 0; i < target.size(); i++) {
            //如果元素的indexVocabulary>maxIndexVocabulary，则说明符合要求的元素都在pre前面的元素中
            if (target.getJSONObject(i).getInteger("indexVocabulary") > maxIndexVocabulary) {
                //end是起点，根据起点往前遍历
                JSONObject end = target.getJSONObject(i);
                //死循环，从end起点元素往前找，找到第一个符合联合查询条件的元素
                while (true) {
                    //判断条件顺序从indexVocabulary—>gradation->lastCreatedTime->disabled,顺序，不符合indexVocabulary条件的就不要比对gradation，不符合gradation的就不要比对lastCreatedTime，以此类推
                    if (end.getInteger("indexVocabulary") <= maxIndexVocabulary && end.getInteger("gradation") <= maxGradation
                            && end.getLong("lastCreatedTime") <= maxLastCreatedTime
                            && end.getInteger("disabled") == disabled) {
                        res = new ArrayList<JSONObject>();
                        //找到符合条件的起始元素，从该元素开始往前遍历，符合条件的加入结果集合中
                        getResArr(end, minIndexVocabulary, minGradation, maxGradation, minLastCreatedTime, maxLastCreatedTime, disabled);

//                        for(int j=0;j<res.size();j++){
//                            res.get(j).put("pre",null);
//                            res.get(j).put("next",null);
//                        }
                        return res;
                    } else {
                        end = end.getJSONObject("pre");
                    }
                }
            }
            //i == target.size() - 1,说明本循环到循环最后一遍了，依然没找到indexVocabulary>maxIndexVocabulary的起点元素，说明该组最后一个元素就是小于maxIndexVocabulary的起点元素，当前元素就是起点
            if (i == target.size() - 1) {
                JSONObject end = target.getJSONObject(i);
                //死循环，从end起点元素往前找，找到第一个符合联合查询条件的元素
                while (true) {
                    //判断条件顺序从indexVocabulary—>gradation->lastCreatedTime->disabled,顺序，不符合indexVocabulary条件的就不要比对gradation，不符合gradation的就不要比对lastCreatedTime，以此类推
                    if (end.getInteger("indexVocabulary") <= maxIndexVocabulary && end.getInteger("gradation") <= maxGradation
                            && end.getLong("lastCreatedTime") <= maxLastCreatedTime
                            && end.getInteger("disabled") == disabled) {
                        res = new ArrayList<JSONObject>();
                        //找到符合条件的起始元素，从该元素开始往前遍历，符合条件的加入结果集合中
                        getResArr(end, minIndexVocabulary, minGradation, maxGradation, minLastCreatedTime, maxLastCreatedTime, disabled);
//                        for(int j=0;j<res.size();j++){
//                            res.get(j).put("pre",null);
//                            res.get(j).put("next",null);
//                        }
                        return res;
                    } else {
                        end = end.getJSONObject("pre");
                    }
                }
            }
        }
        return null;

    }


    List<JSONObject> res = new ArrayList<JSONObject>();

    //往前遍历将符合条件的加入结果集中，直到indexVocabulary<minIndexVocabulary时结束
    void getResArr(JSONObject end, Integer minIndexVocabulary, Integer minGradation, Integer maxGradation, Long minLastCreatedTime, Long maxLastCreatedTime, Integer disabled) throws InterruptedException {

        //当前元素的indexVocabulary>= minIndexVocabulary时，进一步判断，如果符合条件则加入结果集中，并往前遍历，否则结束循环
        if (end.getInteger("indexVocabulary") >= minIndexVocabulary) {


            if (end.getInteger("gradation") >= minGradation && end.getInteger("gradation") <= maxGradation) {
                if (end.getLong("lastCreatedTime") >= minLastCreatedTime && end.getLong("lastCreatedTime") <= maxLastCreatedTime
                ) {
                    if (end.getInteger("disabled") == disabled) {
                        //这里用克隆，防止断开前后连接时影响到构建的索引树
                        JSONObject clone = (JSONObject) end.clone();

                        clone.put("pre", null);
                        clone.put("next", null);
                        //检索到符合联合检索条件的元素，根据元素的ID向主键索引树检索到对应元素的所有信息，加入到结果集中
                        JSONObject id = (JSONObject) getBPlusTree(null, clone.getInteger("id")).clone();
                        //将该元素向前指引的字段断开，不然每个元素都包含了所有前面的元素，没有意义，只会加大集合大小
                        id.put("preObject", null);
                        res.add(id);
                    }
                }
            }
            //如果当前元素的前面有元素，则往前循环，没有元素说明到头了，结束循环
            if (end.getJSONObject("pre") != null) {
                getResArr(end.getJSONObject("pre"), minIndexVocabulary, minGradation, maxGradation, minLastCreatedTime, maxLastCreatedTime, disabled);
            }
        }
    }


    //从上往下构建主键索引树
    @GetMapping("/createBPlusTree")
    public JSONObject createBPlusTree(HttpServletRequest request) throws InterruptedException {

        List<JSONObject> jsonObjects = hardRecordDao.listBy(new HashMap<String, Object>());

        //将数据分11组，每组1000数据
        for (int i = 0; i < 11; i++) {
            JSONObject firstFloor = new JSONObject();
            //每组ID的最小值是i * 1000+1
            firstFloor.put("minIndex", i * 1000 + 1);
            List<JSONObject> secondList = new ArrayList<JSONObject>();
            //将本组的数据再分10组，每组100数据
            for (int j = 0; j < 10; j++) {

                JSONObject secondFloor = new JSONObject();
                //每组ID的最小值是i * 1000 + j * 100+1
                secondFloor.put("minIndex", i * 1000 + j * 100 + 1);
                List<JSONObject> threeList = new ArrayList<JSONObject>();

                //将本组的数据再分10组，每组10数据
                for (int m = 0; m < 10; m++) {

                    JSONObject threeFloor = new JSONObject();
                    //每组ID的最小值是i * 1000 + j * 100 + m * 10+1
                    threeFloor.put("minIndex", i * 1000 + j * 100 + m * 10 + 1);

                    List<JSONObject> leafList = new ArrayList<JSONObject>();
                    //循环原集合，将符合当前第一层当前组，第二层当前组，第三层当前组的数据加入当前层的当前组
                    for (int n = 0; n < jsonObjects.size(); n++) {
                        //判断id是否大于当前第三组的最小值，小于当前组的最大值
                        if (jsonObjects.get(n).getInteger("id") > (i * 1000 + j * 100 + m * 10) && jsonObjects.get(n).getInteger("id") <= (i * 1000 + j * 100 + m * 10 + 10)) {
                            //判断是否是第一层的第一组，第二层的第一组，第三层的第一组，并且叶子集合是0，如果是，说明该元素是索引树的第一个元素，不需要设置连接指向前一个元素
                            if (i == 0 && j == 0 && m == 0 && leafList.size() == 0) {

                                leafList.add(jsonObjects.get(n));
                            } else if (i > 0 && j == 0 && m == 0 && leafList.size() == 0) {//判断不是第一层的第一组，但是是第二层的第一组，第三层的第一组，叶子组的第一个元素，则设置连接指向前一个第一层分组的最后一个元素

                                jsonObjects.get(n).put("preObject", root.get(i - 1).getJSONArray("secondList").getJSONObject(9).getJSONArray("threeList").getJSONObject(9).getJSONArray("leafList").getJSONObject(9));
                                leafList.add(jsonObjects.get(n));
                            } else if (j > 0 && m == 0 && leafList.size() == 0) {//判断不是第一层的第一组，也不是第二层的第一个分组，但是是第三层的第一组，叶子组的第一个元素，则设置连接指向前一个第二层分组的最后一个元素

                                jsonObjects.get(n).put("preObject", secondList.get(j - 1).getJSONArray("threeList").getJSONObject(9).getJSONArray("leafList").getJSONObject(9));
                                leafList.add(jsonObjects.get(n));
                            } else if (m > 0 && leafList.size() == 0) {//判断不是第一层的第一组，也不是第二层的第一个分组，也不是第三层的第一个分组，但是叶子组的第一个元素，则设置连接指向前一个叶子组的最后一个元素

                                try {

                                    jsonObjects.get(n).put("preObject", threeList.get(m - 1).getJSONArray("leafList").getJSONObject(threeList.get(m - 1).getJSONArray("leafList").size() - 1));
                                } catch (Exception e) {
                                    System.out.println();
                                    System.out.println(jsonObjects.get(n).getInteger("id"));
                                    System.out.println(threeList.get(m - 1).getJSONArray("leafList").size());
                                }

                                leafList.add(jsonObjects.get(n));
                            } else {//把以上各层第一个组的第一个元素的特殊情况都排除完了，这里的元素就都是本组内后边的元素，只需要将他们的前置连接设置为前一个元素即可
                                jsonObjects.get(n).put("preObject", leafList.get(leafList.size() - 1));
                                //组件叶子组集合
                                leafList.add(jsonObjects.get(n));
                            }
                        }
                    }
                    //将叶子组集合赋给第三层对象
                    threeFloor.put("leafList", leafList);
                    //组件第三层组集合
                    threeList.add(threeFloor);
                }
                //将第三层组集合赋给第二层
                secondFloor.put("threeList", threeList);
                secondList.add(secondFloor);
            }
            //将第二层组集合赋给第一层
            firstFloor.put("secondList", secondList);
            //构建第一层集合
            root.add(firstFloor);
        }


        return null;

    }

    //根据主键范围检索主键索引树
    @GetMapping("/getBPlusTreeByRang")
    public JSONArray getBPlusTreeByRang(HttpServletRequest request, Integer minId, Integer maxId) throws InterruptedException {

        int sumCount = 0;
        for (int i = 0; i < root.size(); i++) {
            sumCount++;
            if (root.get(i).getInteger("minIndex") > maxId) {
                for (int j = 0; j < root.get(i - 1).getJSONArray("secondList").size(); j++) {
                    sumCount++;

                    if (root.get(i - 1).getJSONArray("secondList").getJSONObject(j).getInteger("minIndex") > maxId) {

                        for (int m = 0; m < root.get(i - 1).getJSONArray("secondList").getJSONObject(j - 1).getJSONArray("threeList").size(); m++) {

                            sumCount++;
                            if (root.get(i - 1).getJSONArray("secondList").getJSONObject(j - 1).getJSONArray("threeList").getJSONObject(m).getInteger("minIndex") > maxId) {
                                JSONArray jsonArray = root.get(i - 1).getJSONArray("secondList").getJSONObject(j - 1).getJSONArray("threeList").getJSONObject(m - 1).getJSONArray("leafList");
                                for (int n = 0; n < jsonArray.size(); n++) {
                                    sumCount++;
                                    if (jsonArray.getJSONObject(n).getInteger("id").intValue() == maxId) {
                                        System.out.println("循环了" + sumCount + "次");
                                        JSONArray resArr = new JSONArray();
                                        JSONObject clone = (JSONObject) jsonArray.getJSONObject(n).clone();
                                        clone.put("preObject", null);
                                        resArr.add(clone);
                                        JSONObject preObj = jsonArray.getJSONObject(n).getJSONObject("preObject");
                                        while (preObj.getInteger("id") >= minId) {

                                            JSONObject clone1 = (JSONObject) preObj.clone();
                                            clone1.put("preObject", null);
                                            resArr.add(clone1);
                                            preObj = preObj.getJSONObject("preObject");
                                        }

                                        return resArr;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        return null;

    }

    @GetMapping("/getBPlusTree")
    public JSONObject getBPlusTree(HttpServletRequest request, Integer id) throws InterruptedException {


        int sumCount = 0;
        JSONArray target = null;
        //循环第一层组集合
        for (int i = 0; i < root.size(); i++) {
            sumCount++;
            //如果本组的最小值大于条件id，则目标数据在前一个第一层分组
            if (root.get(i).getInteger("minIndex") > id) {
                target = root.get(i - 1).getJSONArray("secondList");
                break;
            }
            //如果本组的最小值等于条件id，则目标数据在当前的第一层分组
            if (root.get(i).getInteger("minIndex") == id) {
                target = root.get(i).getJSONArray("secondList");
                break;
            }
            //如果循环最后一遍，没找到第一层分组的最小值minIndex>=id，说明目标数据在最后一个第一层分组（假设我们要找的数据存在）
            if (i == root.size() - 1) {
                target = root.get(i).getJSONArray("secondList");
                break;
            }
        }
        //循环第二层组集合
        for (int j = 0; j < target.size(); j++) {
            sumCount++;
            //如果本组的最小值大于条件id，则目标数据在前一个第二层分组
            if (target.getJSONObject(j).getInteger("minIndex") > id) {
                target = target.getJSONObject(j - 1).getJSONArray("threeList");
                break;
            }
            //如果本组的最小值等于条件id，则目标数据在当前的第二层分组
            if (target.getJSONObject(j).getInteger("minIndex") == id) {
                target = target.getJSONObject(j).getJSONArray("threeList");
                break;
            }
            //如果循环最后一遍，没找到第二层分组的最小值minIndex>=id，说明目标数据在最后一个第二层分组（假设我们要找的数据存在）
            if (j == target.size() - 1) {
                target = target.getJSONObject(j).getJSONArray("threeList");
                break;
            }
        }
        //循环第三层组集合
        for (int j = 0; j < target.size(); j++) {
            sumCount++;

            if (target.getJSONObject(j).getInteger("minIndex") > id) {
                target = target.getJSONObject(j - 1).getJSONArray("leafList");
                break;
            }
            if (target.getJSONObject(j).getInteger("minIndex") == id) {
                target = target.getJSONObject(j).getJSONArray("leafList");
                break;
            }
            if (j == target.size() - 1) {
                target = target.getJSONObject(j).getJSONArray("leafList");
                break;
            }
        }
        //循环叶子组集合
        for (int n = 0; n < target.size(); n++) {
            sumCount++;
            //如果id相等，则获得所要查询的元素
            if (target.getJSONObject(n).getInteger("id").intValue() == id) {
                try {

                    System.out.println("循环了" + sumCount + "次");
                } catch (Exception e) {
                    int i = 9;
                }
                return target.getJSONObject(n);
            }
        }
        return null;

    }
}

一直很很安静
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【MySQL】 B+ 树存储的原理
liuwanqing233333的博客
11-23 3020
本文主要介绍 MySQL 存储引擎 使用 B+ 树存储的原理
B+Tree 在线模拟
qq690452074的专栏
02-16 2709
链接地址：https://www.cs.usfca.edu/~galles/visualization/BPlusTree.html 数据结构可视化：https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
B树&B+树详解
最新发布
2301_80035594的博客
06-10 1298
B树（B-tree）是一种自平衡的树状数据结构，广泛应用于需要高效地插入、删除和查找操作的场景。B树的名称中的“B”代表“平衡（balanced）”，这是因为B树在进行插入和删除操作时，能够保持树的平衡性，即各个分支的深度相对平均。今天就让我们来深入学习一下。
MySQL之索引
weixin_55417005的博客
06-08 350
MySQL学习 索引失效、有效场景 explain详解
B-树，B+树
m0_51641706的博客
04-16 2270
B树的孩子有左父亲和右父亲，父亲又有左孩子和右孩子。且一个节点既能做左孩子也能做右孩子，很奇妙的树！ 文章目录B树规则定义B树的插入过程根据分裂过程记忆性质（重要） B树规则定义 一棵M阶(M>2)的B树，是一棵平衡的M路平衡搜索树，可以是空树或 者满足一下性质： 1. 根节点关键字的数量是[1,M-1] 2. 根节点孩子的数量树[2,M] 3. 每个非根节点至少有M/2(上取整)个孩子,至多有M个孩子 4. 每个非根节点至少有M/2-1(上取整)个关键字,至多有M-1个关键字 5. 所有的叶子节点都
数据结构 第六章 查找(一) B树,B+树
Jay_fearless的博客
08-06 605
1. 查找的基本概念 (1) 平均查找长度 ASL = 每个元素 查找概率 * 找到第i个元素需要进行的比较次数 的和。 (2) 决策树(判定树) 2. 顺序查找法 (1) 一般线性表的顺序查找 a. 若每个元素查找概率相同，则 ASL(成功) = 1+2+...+nn\frac{1 + 2 + ... + n}{n}n1+2+...+n​= n+12\frac{n+1}{2}2n+1​ b. ASL(失败) = n或n+1，取决于代码写法。 (2) 有序表的顺序查找 a. 若每个元素查找概率相同，则 A
shady-dom:树下阴凉，不粗略
06-13
树下阴凉，不粗略。 import { registerElement } from 'shady-dom' ; @ registerElement ( ) class XFoo extends window . HTMLElement { createdCallback ( ) { const root = this . createShadyRoot ( ) ; ...
八叉树颜色量化_八叉树_
09-30
此外，由于八叉树结构，查询和插入操作相对高效，适用于大数据量的图像处理。 然而，八叉树颜色量化也存在一些局限性。例如，对于颜色分布不均匀的图像，可能会导致某些颜色区域过度细化，而其他区域则过于粗略。...
毕业设计&课设-粗略网格占用图模拟.zip
01-08
matlab算法，工具源码，适合毕业设计、课程设计作业，所有源码均经过严格测试，可以直接运行，可以放心下载使用。有任何使用问题欢迎随时与博主沟通，第一时间进行解答！ matlab算法，工具源码，适合毕业设计、课程...
GPS信号的模拟捕获和跟踪仿真
05-07
在GPS（全球定位系统）技术中，信号的模拟捕获和跟踪是至关重要的步骤，它们是接收机定位和导航的基础。下面将详细解释这些概念及其相关知识点。 首先，我们要了解GPS信号的基本结构。GPS信号主要由载波、伪随机...
Android系统模拟位置的使用方法
08-13
然后，通过`setTestProviderEnabled()`方法启用这个模拟位置提供商，并使用`setTestProviderLocation()`或`setTestProviderStatus()`方法来设置具体的位置和状态。 5. **恢复真实位置** 在完成测试后，记得使用`...
B+树（利用文件实现）
06-28
B+树实现，利用文件在硬盘上存储，具体使用说明在文档中
可视化B-树演示系统
01-03
可视化B-树演示系统，使用MFC制作，包括创建、删除、插入
swing版的b+树实现及演示程序
09-06
这个程序是swing版本的b+树的实现及演示，适合学些b+树实现方式的同学们，详细情况可以参考我的博文：http://blog.csdn.net/cdnight/article/details/10973281， 希望对大家有所帮助。
B+树实现的存储
01-11
最近看了B+树的存储，在网上找到几个实例，最后把一个作者整理的分享下。该源码来自网上，作者说已经在生产环境使用，所以选择了它
二叉树、B树和B+树等数据结构模拟网站
大话家的博客
07-12 2250
推荐一个网站，地址如下： https://www.cs.usfca.edu/~galles/visualization/Algorithms.html 该网站可以模拟相当多种类的数据接口的插入、删除和查找步骤。 下面，以B树为例做说明。
【高阶数据结构】 B树 -- 详解
Elena's Blog
05-20 1437
简化 B树 孩子比关键字多一个的规则，变成相等。所有值都在叶子上，方便遍历查找所有值。
浅析Mysql索引Innodb及底层存储结构B+树
gaoyunshan163的博客
01-09 3908
前言 最近博主在学习mysql索引相关知识，看了很多博客，公开课然后自己总结一下，最近的收获吧。本文从二叉树->平衡二叉树->B树（有同学读B减树，是不正确的） ->B+树 再到B+树在Myisam和Innodb中的体现形式，会提到索引失效的情况，以及创建索引时的一些注意事项及其原理。采用大量的图片+部分文字更加清晰的描述。其中部分图片来源于咕泡学院公开课。 准备 提到my...
B-、B树详解及模拟实现
wolfGuiDao的博客
06-07 1015
B-、B、B+树简介及模拟实现 文章目录B-、B、B+树简介及模拟实现一、B树二、B-树1.性质2.特性三、B+树1.性质2.特性四、B*树五、摸拟实现B+树 一、B树 B树就是二叉搜索树： 二叉搜索树详解 二、B-树 1970年，R.Bayer和E.mccreight提出了一种适用于外查找的树，它是 一种平衡的多叉树。 1.性质 一棵M阶B-树(balanced tree of order m)是一棵平衡的M路搜索树。它或者是空树，或者是满足 下列性质 的树： 1.定义任意非叶子结点最多只有M个儿子；
innodb中，b+树默认大小为16KB，假如一个key大小8字节，那么可以存放多少个key
07-17
根据InnoDB的B+树默认大小为16KB，假设一个key的大小为8字节。在B+树的内部节点中，除了存储key值外还需要存储指向子节点的指针。假设指针大小为4字节，每个节点的大小为12字节（8字节的key加上4字节的指针）。因此，一个内部节点可以存储16KB / 12B ≈ 1365个key。 然而，在实际情况下，B+树的叶子节点存储了实际的数据记录而不是仅仅存储key值。因此，一个叶子节点可以存储的key数量会更少。具体数量还要考虑记录的大小，以及InnoDB对数据页的管理和存储格式等因素。 需要注意的是，这只是一个粗略的计算，实际情况可能会因为包含其他额外开销而有所不同。若要获取更准确的结果，可以参考InnoDB的文档或者使用实际测试来评估。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值