java数据结构 基本查找,二分查找,分块查找

算法查找

基本查找

又叫顺序查找 从0索引开始挨个往后查找
需求 定义一个方法利用基本查找 查找某个元素是否存在
{132,135,65,86,89,6}

  public static void main(String[] args) {

        int arr[]={132,135,65,86,89,6};
        int searchNumber=65;
        boolean b = basicSearch(arr, searchNumber);
        System.out.println(b);


    }

    private static boolean basicSearch(int arr[], int searchNumber) {

        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==searchNumber){
                return true;
            }

        }
        return false;

    }

定义一个方法利用基本查找 查询某个元素在数组中的索引
烤炉数组中元素有重复的可能性
int arr[]={6,135,65,86,89,6} 我要查询6 返回索引为0和5

public static void main(String[] args) {
        //定义一个方法利用基本查找 查询某个元素在数组中的索引
        //烤炉数组中元素有重复的可能性
        //int arr[]={6,135,65,86,89,6} 我要查询6  返回索引为0和5

        int arr[]={6,135,65,86,89,6};
        int searchNumber=6;
        ArrayList<Integer> integers = basicSearch(arr, searchNumber);

        for (int i = 0; i < integers.size(); i++) {
            Integer integer = integers.get(i);
            System.out.println(integer);
        }


    }

    private static ArrayList<Integer> basicSearch(int arr[], int searchNumber) {

        ArrayList<Integer>list=new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==searchNumber){
                list.add(i);
            }

        }
        return list;

二分查找

二分查找1的数组中数据必须是有序的
核心思想:每次排除一半的查找范围

    public static void main(String[] args) {

        int arr[]={4,23,67,14,126,33};
        int number=67;
        int i = binarySearch(arr, number);
        System.out.println(i);


    }

    public static int binarySearch(int arr[], int number) {
        
        //定义两个变量记录要查找到范围
        int min=0;
        int max=arr.length-1;
        //2利用循环不断求要找到的数据
        while (true){
            if(min>max){//如果遇到这个条件相当于循环完了
                return -1;
            }

            //找到 mid位置
            int mid=(min+max)/2;

            //拿着mid指向元素跟查找的元素比较
            if(arr[mid]>number){
                //number在mid左边  min不变 max等于mid-1
                max=mid-1;

            }else if(arr[mid]<number) {
                //number在mid又边  max不变 min等于mid+1)
                min = mid + 1;

            }else{
                //number和mid指向元素一样 找到了
                return mid;
            }


        }

    }

优化方式 插值查找了解即可

斐波那契查找 了解

以上总结

分块查找

把获得到的数据分成若干个小块
第一块是最小 第一块中最大数据值不会大于第二块所有数据,第二快中最大数据不会大于第三块所有数据…

思路:分成四块每块定义成一个类 类的内容记录了 该块的最大值起始索引和结束索引,然后把这四块对象存在数组内进行调用.如下图

  public static void main(String[] args) {

        int arr[]={16,5,9,12,21,18,
                32,23,37,26,45,34,
                50,48,61,52,73,66};
        //分成了三块.分块思路总数开根号 这个是16个  开根号等于4.5左右


        //定义一个类存储三个组
        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=37;
        //要查询的数

        //调用方法传递索引表 要查询的数据 arr数组
        int index = getIndex(blockarr, arr, number);
        System.out.println(index);


    }

    private static int getIndex(Block[] blockarr, int[] arr, int number) {
        //在这之前要知道要查询的数number在哪个组里
        //定义一个方法
        int numberIndex = getNumberIndex(blockarr, number);
        //numberIndex就是找到的符合的组块索引
        //获取这块索引得最大值 起始索引和结束
        int endIndex = blockarr[numberIndex].getEndIndex();
        int maxIndex = blockarr[numberIndex].getMaxIndex();
        int startIndex = blockarr[numberIndex].getStartIndex();

        //遍历该组
        for (int i = startIndex; i < endIndex; i++) {
            if(arr[i]==number){
                return i;
            }

        }
        return -1;


    }

    private static int getNumberIndex(Block[] blockarr, int number) {

        for (int i = 0; i < blockarr.length; i++) {
            //思路 获取每个组中最大数  找到比要查询的数小的哪个就是



            if(blockarr[i].getMaxIndex()>number){
                return i;
            }



        }



        return -1;//找不到直接返会-1结束代码

    }
}
class Block{
    private int maxIndex;
    private int startIndex;
    private int endIndex;


    public Block() {
    }

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

    /**
     * 获取
     * @return maxIndex
     */
    public int getMaxIndex() {
        return maxIndex;
    }

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

    /**
     * 获取
     * @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{maxIndex = " + maxIndex + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
    }
}