分块，分块扩展，哈希查找

查找算法：

基本查找是数据没有任何顺序；

二分查找，插值查找，斐波那契查找是要求数据有一定顺序；

大多数数据并非没有任何顺序，但是又乱中有序，此时可以用分块查找：

一.分块查找

分块的原则1：前一块中的最大数据，小于后一块中所有的数据（块内无序，块间有序）

分块的原则2：块数数量一般等于数字的个数开根号，比如：16个数字一般分为4块左右；

核心思路：先确定要查找的元素在哪一块，然后在块内挨个查找。

public class BlockSearchDemo1 {
    public static void main(String[] args) {
        //1.分块查找：把数据进行分块
        //要分为几块呢？总数开根号；14开根号
        int[] arr={16,5,9,12,21,18,
                   32,23,37,26,45,34,
                    50,48,61,52,73,66};

        //创建三个块的对象；
        Block b1=new Block(21,0,5);
        Block b2=new Block(45,6,11);
        Block b3=new Block(73,12,17);
        //定义数组，用来管理三个块的对象；
        Block[] blockArr={b1,b2,b3};
        //定义一个变量用来记录要查找的元素；
        int number=18;
        //调用方法：传递索引表，数组，还有要查找的元素；
        int index=getIndex(blockArr,arr,number);

        //打印一下
        System.out.println(index);

    }
    //利用分块查找的原理，查询number的索引；
    private static int getIndex(Block[] blockArr, int[] arr, int number) {
       //1.确定number是在哪一块中
        int indexBlock=findIndexBlock(blockArr,number);
        if(indexBlock==-1){
            return -1;
        }
        //获取这一块的起始索引和结束索引；
        int startIndex=blockArr[indexBlock].getStartIndex();
        int endIndex=blockArr[indexBlock].getEndIndex();
         //3.遍历
        for (int i = startIndex; i <=endIndex ; i++) {
            if(arr[i]==number){
                return i;
            }
        }
        return 0;
    }
    public static int findIndexBlock(Block[] blockArr,int number){
        for(int i=0;i<blockArr.length;i++){
            if(number <=blockArr[i].getMax()){
               return i;
            }
        }
        return-1;
    }
}
class Block{
    private int max;//最大值；
    private int startIndex;//起始索引；
    private int endIndex;//结束索引；


    public Block() {
    }

    public Block(int max, int startIndex, int endIndex) {
        this.max = max;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

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

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

    /**
     * 获取
     * @return startIndex
     */
    public int getStartIndex() {
        return startIndex;
    }

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

    /**
     * 获取
     * @return endIndex
     */
    public int getEndIndex() {
        return endIndex;
    }

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

    public String toString() {
        return "Block{max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
    }
}

扩展的分块查找（哈希查找）：

//需求：在1~1000之间获取100个数据，要求数据不重复；