基本查找/二分查找/分块查找（Java）

基本查找

1.什么是基本查找

        基本查找又叫顺序查找，是简单粗暴的一种查找方法，只需要从0索引开始依次对后面的元素进行查找，判断某个元素是否存在。

2.基本使用实现

        需求：定义一个方法利用基本查找，查询某个元素是否存在
        数据如下：{131，127，147，81，103，23，7，79}

3.代码实现

public class Jiben_chazhao {
    public static void main(String[] args) {
       

        int []arr={131,127,147,81,103,23,7,79};
        int number=81;
        System.out.println(basicSearch(arr,81));
    }
    //参数
    //1.数组
    //2.要查找的元素

    //返回值：
    //元素是否存在
    public static boolean basicSearch(int []arr,int number){
        //利用基本查找来查找number在数组中是否存在
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]==number){
                return true;
            }
        }
        return false;
    }
}

4.提升案例

        需求：定义一个方法利用基本查找，查询某个元素在数组中的索引
        要求：需要考虑数组中有重复的可能性

5.代码实现

public class Jinben_chazhao_test1 {
    public static void main(String[] args) {
       
        int []arr={131,127,147,81,103,23,7,79,81};
        int number=81;
        System.out.println(basicSearch(arr,81));
    }
    //如果我们要返回多个数据的话，可以把这些数据放到数组或集合中

    public static List<Integer> basicSearch(int []arr, int number){
        ArrayList<Integer>list=new ArrayList<>();
        for(int i=0;i< arr.length;i++){
            if(arr[i]==number){
                list.add(i);
            }
        }
        List<Integer>result=getList(list);
      return getList(list);

    }

    private static List<Integer> getList(ArrayList<Integer> list) {
        List<Integer>result=new ArrayList<>();
        for(int i:list){
            result.add(i);
        }
        return result;
    }


}

代码输出结果

二分查找

1.什么是二分查找

        二分查找也叫做折半查找，指在有序数组中，搜索要查找的数，利用数组中的那个数与所需要查找的那个数做比较，通过移动min和max来找到所需要查找的数。

2.算法步骤具体如下

3.基本使用实现

public class ErFen_chazhao {
    public static void main(String[] args) {
       
        int[] arr = {7, 23, 79, 81, 103, 127, 131, 147};
        System.out.println(basicSearch(arr, 79));

    }

    public static int basicSearch(int[] arr, int number) {
        int min = 0;
        int max = arr.length - 1;
        while (true) {
            if (min > max) {
                return -1;
            }
            int mid = (min + max) / 2;
            //number在mid右面
            if (arr[mid] < number) {
                min = mid + 1;
            } //number在mid左面
            else if (arr[mid] > number) {
                max = mid - 1;

            } else {
                return mid;
            }
        }
    }
}

代码输出结果

分块查找

1.什么是分块查找

分块查找就是将数组元素分为若干块并建立索引表，对于块内部元素而言可以是无序的，但是块与块之间要有顺序，第一块的最大值要小于第二块的任何元素，以此类推。根据要查找元素的大小，在索引表确定目标元素可能出现的块，然后在那个块内进行搜索。

2.基本使用实现

1.创建数组blockArr存放每一个对象的信息
2.先查找blockArr确定要查找的数据属于哪一块
3.再单独遍历这一块数据即可

arr[] = {16, 5, 9, 21, 18,32, 23, 37, 26, 45, 34,50, 48, 61, 52, 73, 66};

3.代码实现

public class Fenkuai_Chazhao {
    public static void main(String[] args) {
  

        int[] arr = {16, 5, 9, 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 = 30;
        //调用方法：传递索引表，数组，要查找的元素
        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) {
            //表示number不在数组中
            return -1;
        }
        //2.获取这一块的起始索引和结束索引
        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 -1;
    }

    //定义一个方法，用来确定number在那一块中
    public static int findIndexBlock(Block[] blockArr, int number) {
        //从0索引开始遍历blockArr，如果number小于max，那么就表示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表示不存在