chapter6 查找算法

线性查找，顺序查找

数据可以是有序的也可以是无序的

public class SeqSearch {
    public static void main(String[] args) {
        int[] arr={1,9,11,-1,34,89};//无序数组
        int index=seqSearch(arr,-11);
        if(index==-1){
            System.out.println("没有找到");
        }else{
            System.out.println("找到了，下标为："+index);
        }
    }

    //找到一个就返回，这个一个是在前面的那个
    public static int seqSearch(int[] arr,int value){
        //线性查找的逐一比对，发现有相同值，就返回下标
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==value){
                return i;
            }
        }
        return -1;
    }
}

二分查找

要求：在有序数组中进行查找

二分查找的思想

二分查找的基本写法(递归)

package search;

/**
 * @author : sky
 * @version : 1.0
 */
public class BinarySearch {
    public static void main(String[] args) {
        //使用二分查找的前提是该数组是有序的
        int[] arr={1,8,10,89,1000,1234};
        int resIndex = binarySearch(arr, 0, arr.length - 1, 88);
        if(resIndex==-1){
            System.out.println("没有找到");
        }else{
            System.out.println("找到了，下标为："+resIndex);
        }
    }

    //二分查找

    /**
     *
     * @param arr 数组
     * @param left 左边索引
     * @param right 右边索引
     * @param findVal 要查找的值
     * @return 如果找到返回下标，如果没有找到返回-1
     */
    public static int binarySearch(int[] arr,int left,int right,int findVal){
        //当left>right时，说明递归了整个数组，也没有找到
        if(left>right){
            return -1;
        }
        int mid=(left+right)/2;
        int midVal=arr[mid];
        if(findVal>midVal){//如果大于，向右递归
            return binarySearch(arr,mid+1,right,findVal);
        }else if(findVal<midVal){//如果小于，向左递归
            return binarySearch(arr,left,mid-1,findVal);
        }else if(findVal==midVal){
            return mid;
        }
        return -1;
    }
}

思考题：

package search;

import java.util.ArrayList;
import java.util.List;

/**
 * @author : sky
 * @version : 1.0
 */
public class BinarySearch {
    public static void main(String[] args) {
        //使用二分查找的前提是该数组是有序的
        int[] arr={1,8,10,89,1000,1000,1234};
        List<Integer> resIndexList = binarySearch2(arr, 0, arr.length - 1, 1000);
        System.out.println("查找的下标集合为："+resIndexList);//[4, 5]
    }


    //二分查找：有多个相同的数值时，如何将所有的数值都查找到
    /**
     * 思路分析：
     * 1.在找到mid值时，不要马上返回
     * 2.向mid索引值的左边扫描，将所有满足1000元素的下标，加入到一个集合中
     * 3.向mid索引值的右边扫描，将所有满足1000元素的下标，加入到一个集合中
     * 4.将集合返回
     */
    public static List<Integer> binarySearch2(int[] arr, int left, int right, int findVal){
        //当left>right时，说明递归了整个数组，也没有找到
        if(left>right){
            return new ArrayList<Integer>();
        }
        int mid=(left+right)/2;
        int midVal=arr[mid];
        if(findVal>midVal){//如果大于，向右递归
            return binarySearch2(arr,mid+1,right,findVal);
        }else if(findVal<midVal){//如果小于，向左递归
            return binarySearch2(arr,left,mid-1,findVal);
        }else if(findVal==midVal){
            List<Integer> resIndexList = new ArrayList<>();
            //向mid索引值的左边扫描，将所有满足1000元素的下标，加入到一个集合中
            int temp=mid-1;
            while(true){
                if(temp<0 || arr[temp]!=findVal){//退出
                    break;
                }
                resIndexList.add(temp);//否则将temp放入到集合中
                temp--;//temp左移
            }

            resIndexList.add(mid);

            //向mid索引值的右边扫描，将所有满足1000元素的下标，加入到一个集合中
            temp=mid+1;
            while(true){
                if(temp>arr.length-1 || arr[temp]!=findVal){
                    break;
                }
                resIndexList.add(temp);
                temp++;//temp右移
            }
            return resIndexList;
        }
        return new ArrayList<Integer>();
    }
}

二分查找(非递归)

package binarysearchnorec;

/**
 * @author : sky
 * @version : 1.0
 */
public class BinarySearchNS {
    public static void main(String[] args) {
        int[] arr={1,3,8,10,11,67,100};
        int index=binarySearch(arr,8);
        System.out.println(index);
    }

    /**
     * //二分查找的非递归实现
     * @param arr 待查找的数组，arr是升序排序
     * @param target 需要查找的数
     * @return 返回对应下标，-1表示没有找到
     */
    public static int binarySearch(int[] arr,int target){
        int left=0;
        int right=arr.length-1;
        while(left<=right){//说明可以继续查找
            int mid=(left+right)/2;
            if(arr[mid]==target){
                return mid;
            }else if(arr[mid]>target){
                right=mid-1;//需要向左边查找
            }else{
                left=mid+1;//需要向右边查找
            }
        }
        return -1;
    }
}

插值查找

package search;

import java.util.Arrays;

/**
 * @author : sky
 * @version : 1.0
 */
public class InsertValueSearch {
    public static void main(String[] args) {
        int[] arr=new int[100];
        for (int i = 0; i <100 ; i++) {
            arr[i]=i+1;
        }
        //System.out.println(Arrays.toString(arr));
        int resIndex = insertValueSearch(arr, 0, arr.length - 1, 1 );
        System.out.println("resIndex="+resIndex);
    }

    //插值查找
    //要求数组有序
    public static int insertValueSearch(int[] arr,int left,int right,int findVal){
        //如果没找到或者，查找的值比最小的还小，或者查找的值比最大的还大
        //findVal<arr[0] || findVal>arr[arr.length-1] 这两句话必须要，否则mid值可能越界
        //比如说如果要查找一个巨大的数，结果mid算出来也巨大，mid可能会越界
        if(left>right || findVal<arr[0] || findVal>arr[arr.length-1]){
            return -1;
        }
        //自适应写法
        int mid=left+(right-left)*(findVal-arr[left])/(arr[right]-arr[left]);
        int midVal=arr[mid];
        if(findVal>midVal){//如果大于，向右递归
            return insertValueSearch(arr,mid+1,right,findVal);
        }else if(findVal<midVal){//如果小于，向左递归
            return insertValueSearch(arr,left,mid-1,findVal);
        }else if(findVal==midVal){
            return mid;
        }
        return -1;
    }
}

斐波那契查找，黄金分割查找

要求：有序数组

package search;

import java.util.Arrays;

/**
 * @author : sky
 * @version : 1.0
 */
public class FibonacciSearch {
    public static int maxSize=20;
    public static void main(String[] args) {
        int[] arr={1,8,10,89,1000,1234};
        System.out.println(fibSearch(arr,1234));
    }

    //因为要使用到斐波那契数列，需要先获取到斐波那契数列
    //非递归方式得到斐波那契数列
    public static int[] fib(){
        int[] f=new int[maxSize];
        f[0]=1;
        f[1]=1;
        for (int i = 2; i <maxSize ; i++) {
            f[i]=f[i-1]+f[i-2];
        }
        return f;
    }

    //斐波那契查找，使用非递归的方式编写
    /**
     * 要求数组有序
     * @param arr 数组
     * @param key 需要查找的关键字
     * @return 返回对应的下标，没有就返回-1
     */
    public static int fibSearch(int[] arr,int key){
        int low=0;
        int high=arr.length-1;
        int k=0;//表示斐波那契分割数值的下标
        int mid=0;//存放mid值
        int f[]=fib();//获取到斐波那契数列

        //获取斐波那契分割数值的下标
        while(high>f[k]-1){
            k++;
        }
        //因为f[k]这个值可能大于数组arr的长度，因此需要使用Arrays类，构造一个新的数组并指向arr[]
        //不足的部分会使用0填充
        int[] temp= Arrays.copyOf(arr,f[k]);
        //实际上需要使用arr数组最后的数填充temp
        //举例：
        //temp={1,8,10,89,1000,1234，0，0};===》{1,8,10,89,1000,1234，1234，1234}
        for (int i = high+1; i <temp.length ; i++) {
            temp[i]=arr[high];
        }

        //使用while来循环处理，找到key
        while(low<=high){
            mid=low+f[k-1]-1;
            if(key<temp[mid]){//继续向数组左边查找
                high=mid-1;
                //为什么k--？
                //说明：
                //1.全部元素 = 前面的元素 + 后面的元素
                //2.f[k]=f[k-1]+f[k-2]
                //因为前面有f[k-1]个元素，所以继续拆分f[k-1]=f[k-2]+f[k-3]
                //即在f[k-1]的前面继续查找
                //即下次循环mid=f[k-1-1]-1
                k--;
            }else if(key>temp[mid]){//继续向数组右边查找
                low=mid+1;
                //为什么k-=2？
                //说明：
                //1.全部元素 = 前面的元素 + 后面的元素
                //2.f[k]=f[k-1]+f[k-2]
                //因为后面有f[k-2]个元素，所以继续拆分f[k-2]=f[k-3]+f[k-4]
                //即在f[k-2]的前面继续查找 k-=2
                //即下次循环mid=f[k-1-2]-1
                k-=2;
            }else{
                //需要确定返回的时哪个下标
                if (mid<=high){
                    return mid;
                }else {
                    return high;
                }
            }
        }
        return -1;
    }
}