查询学习（一）

无规律的分段查询

在一些情况，不好使用顺序查询，二分查询，以及有规律的分段查询，数字往往是杂乱的，这个时候可以使用无规律的分段查询，例如：

27,22,30,40,36,
13,19,16,20,
7,10,
43,50,48

这段数字虽然没有具体规律，但是在每一行中存在最大值和最小值，且在最大最小值组成的范围之间，各行的范围没有交集，这个时候能用无规律的分段查询。

1、先使用每段的最小最大值组成的范围来判断要查询的数字在哪一段，而每一段能用数组存储起来，使用时直接返回该段的数组索引，例如我需要查询20，即在上诉数组中将数字分为4段，20明显在第2段中，而在段数组成的数组中返回的索引就应该为1。

2、在得到数字在数组中的段数后，即在该段的数组里，用遍历的方式得到该数字在整个数组也就是{27,22,30,40,36, 13,19,16,20, 7,10, 43,50,48}中的索引，从而实现查询数字的目的

具体代码如下：

package com.itazhang.demo7;

import java.util.concurrent.BlockingDeque;


public class Test3 {
    public static void main(String[] args) {
        int[] arr = {
                27,22,30,40,36,
                13,19,16,20,
                7,10,
                43,50,48
        };
        int num = 20;
        Block b1 = new Block(22,40,0,4);
        Block b2 = new Block(13,20,5,8);
        Block b3 = new Block(7,10,9,10);
        Block b4 = new Block(43,50,11,13);
        Block[] blocksarr = {b1,b2,b3,b4};
        int index = getIndex(arr, num, blocksarr);
        System.out.println("需要查询的数字索引是" + index);


    }
    //这个方法是用来匹配每个模块的范围里是否包含要查找的数，如果包含，返回该模块在这个模块数字中的索引
    public static int findIndexBloker(Block[] blocks,int num){
        for (int i = 0; i < blocks.length; i++) {
            if(num >= blocks[i].getMin() && num <= blocks[i].getMax()){
                return i;
            }
        }
        return -1;
    }
    //这个方法是在已经确定该数在某个模块里，用遍历在这个模块里匹配该数，如果匹配到，返回该数在模块内的索引
    public static int getIndex(int[] arr,int num,Block[] b){
        int index = 0;
        //调用findINdexBloker方法，找到需要查询的数字具体在哪个blocker内
        int bindex = findIndexBloker(b,num);
        //如果要查询的数没有在所有模块的范围内，返回-1
        if(bindex == -1){
            //表示number不在数组当中
            return -1;
        }
        int startindex = b[bindex].getStarindex();
        int endindex = b[bindex].getEndindex();
        for (int i = startindex; i <= endindex; i++) {
            if(arr[i] == num){
                return i;
            }
        }
        return -1;
    }

}
class Block{
    private int min;//数据块里最小值
    private int max;//数据块里的最大值
    private int starindex;//该数据块的起始索引
    private int endindex;//该数据块的最终索引

    public Block() {
    }

    public Block(int min, int max, int starindex, int endindex) {
        this.min = min;
        this.max = max;
        this.starindex = starindex;
        this.endindex = endindex;
    }

    /**
     * 获取
     * @return min
     */
    public int getMin() {
        return min;
    }

    /**
     * 设置
     * @param min
     */
    public void setMin(int min) {
        this.min = min;
    }

    /**
     * 获取
     * @return max
     */
    public int getMax() {
        return max;
    }

    /**
     * 设置
     * @param max
     */
    public void setMax(int max) {
        this.max = max;
    }

    /**
     * 获取
     * @return starindex
     */
    public int getStarindex() {
        return starindex;
    }

    /**
     * 设置
     * @param starindex
     */
    public void setStarindex(int starindex) {
        this.starindex = starindex;
    }

    /**
     * 获取
     * @return endindex
     */
    public int getEndindex() {
        return endindex;
    }

    /**
     * 设置
     * @param endindex
     */
    public void setEndindex(int endindex) {
        this.endindex = endindex;
    }

    public String toString() {
        return "Block{min = " + min + ", max = " + max + ", starindex = " + starindex + ", endindex = " + endindex + "}";
    }
}