查找 算法

 

/**
 * 顺序查找
 */
public class shunxu {
    public static void main(String[] args) {
        int[] arr={9,78,65,543,5,3,54,6};
        int index=Search(arr,5);
        if(index==-1){
            System.out.println("没有找到");
        }else {
            System.out.println(index);
        }
    }
    private static int Search(int[] arr,int v){
        for (int i=0;i<arr.length;i++){
            if(v==arr[i]){
                return i;
            }
        }
        return -1;
    }
}

 

 

/**
 * 二分查找
 */
public class erfen {
    public static void main(String[] args) {
        int[] arr={6,55,4,34,65,76,55,76,55,55};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        ArrayList arrayList=Search(arr,0,arr.length,55);
        System.out.println(arrayList);

    }
    private static ArrayList<Integer> Search(int[] arr,int left,int right,int v){
        if (left>right){
            return new ArrayList<>();
        }else {
           int mid=(left+right)/2;
           if(arr[mid]>v){
               return Search(arr,left,mid-1,v);
           }else if(v>arr[mid]){
               return Search(arr,mid+1,right,v);
           }else {
               ArrayList<Integer> arrayList=new ArrayList<>();
               arrayList.add(mid);
               int temp=mid+1;
               while (true){
                   if (temp>arr.length-1||arr[temp]!=v){
                       break;
                   }else {
                       arrayList.add(temp);
                       temp++;
                   }
               }
               temp=mid-1;
               while (true){
                   if (temp<0||arr[temp]!=v){
                       break;
                   }else {
                       arrayList.add(temp);
                       temp--;
                   }
               }
               return arrayList;
           }
        }
    }
}

/**
 * 插值查找
 */
public class InsertSearch {
    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 num=Search(arr,0,arr.length-1,1);
    //只执行一次
        System.out.println(num);
    }
    private static int Search(int[] arr,int left,int right,int v){
        //和二分查找几乎一致，mid发生改变
        System.out.println("hello");
        int mid=left+((v-arr[left])/(arr[right]-arr[left]))*(right-left);
        if (left>right||v<arr[0]||v>arr[arr.length-1]){
            return -1;
        }else if (v>arr[mid]){
            return Search(arr,mid+1,right,v);
        }else if (v<arr[mid]){
                return Search(arr,left,mid-1,v);
        }else {
            return mid;
        }
    }

}

/**
 * 斐波那列查找算法
 */

public class FibonacciSearch {
    private static int maxsize=20;
    public static void main(String[] args) {
        int[] arr={7,6,4,54,5,4,667,654,34};
        int num=Search(arr,5);
        System.out.println(num);
    }

    //获取一个斐波那列数列
    private static int[] fibonacci(){
        int[] f=new int[maxsize];
        f[0]=1;
        f[1]=1;
        for(int i=2;i<f.length;i++){
            f[i]=f[i-1]+f[i-2];
        }
        return f;
    }
    //编写斐波那列查找算法

    /**
     *
     * @param arr 传入要查找的数组
     * @param v 传入要查找的值
     * @return 返回下标，没有返回-1
     */
    private static int Search(int[] arr,int v){
        int left=0;
        int right=arr.length-1;
        int mid=0;
        int k=0;//斐波那列下标
        int[] f=fibonacci();//获取斐波那列
        //获取肥波那列分割数值下标
        while (right>f[k]-1){
            k++;
        }
        //定义一个新数字，复制arr的值，剩余位置用最后一个数字填充
        int[] a= Arrays.copyOf(arr,f[k]);
        for(int i=right+1;i<f[k];i++){
            a[i]=arr[right];
        }
        //查找下标
        while (left<=right){
            mid=left+f[k-1]-1;
            if (v>a[mid]){
                left=mid+1;
                k-=2;
            }else if(v<a[mid]){
                right=mid-1;
                k--;
            }else {
                if (mid<=right){
                    return mid;
                }else {
                    return right;
                }
            }
        }
        return -1;
    }
}