java--算法--查找算法

转载

mob604756f56fd6 2021-07-12 21:56:00

文章标签 查找算法 i++ 测试类插值 java 文章分类 Java 后端开发

查找算法的介绍：

查找算法的具体实现：

线性查找算法

package com.model.search;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/7/12 16:42
 * 查找算法：
 * 线性查找算法
 */
public class SearchDemo01 {
    //线性查找：逐一比对找到和查找的值一样的下标
    public static void main(String[] args) {

        int[] array={1,2,33,4,4545,545,5,212,6};
        System.out.println(linearSearch(array, 6));

    }
    public static int  linearSearch(int[] array,int value){
        for (int i = 0; i < array.length; i++) {
            if (array[i]==value){
                return i;
            }
        }
        return -1;

    }
}

二分查找算法：

package com.model.search;

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

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/7/12 16:58
 * 查找算法：
 * 二分查找算法
 */
public class SearchDemo02 {
    //前提是有序的数组
    public static void main(String[] args) {
        int[] array = {0, 1, 2, 3, 4,5,5, 6, 7, 8, 9};

//        System.out.println(binarySearch(array, 5, 0, 9));
        //若集合中有重复的元素，返回集合中所有要查找的元素
        List<Integer> list = binarySearch02(array, 5, 0, 9);
        list.forEach(System.out::println);
    }

    //二分查找的基本算法
    public static int binarySearch(int[] array, int value, int left, int right) {
        if (left > right) {
            return -1;
        }
        int mid = (left + right) / 2;
        if (array[mid] > value) {
            return binarySearch(array, value, left, mid - 1);
        } else if (array[mid] < value) {
            return binarySearch(array, value, mid + 1, right);
        } else {
            return mid;
        }
    }
    //如果查找的元素有多个需要将多个元素全部返回
    public static List<Integer> binarySearch02(int[] array, int value, int left, int right) {
        if (left > right) {
            return new ArrayList<Integer>();
        }
        int mid = (left + right) / 2;
        if (array[mid] > value) {
            return binarySearch02(array, value, left, mid - 1);
        } else if (array[mid] < value) {
            return binarySearch02(array, value, mid + 1, right);
        } else {
            //再找到mid值是，我们不要立即返回，还要向mid向左向右扫描，找到所有的查找值，放在一个集合中返回
            ArrayList<Integer> list = new ArrayList<>();
            int tempLeft=mid-1;
            while(true){
                if (tempLeft<0||array[tempLeft]!=value){
                    break;
                }
                list.add(array[tempLeft]);
                tempLeft--;
            }
            list.add(mid);
            int tempRight=mid+1;
            while(true){
                if (tempRight>array.length-1||array[tempRight]!=value){
                    break;
                }
                list.add(array[tempRight]);
                tempRight++;
            }
            return list;
        }
    }
}

插值查找算法：

package com.model.search;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/7/12 17:44
 * 查找算法：
 * 插值查找算法（Interpolation search）
 *
 */
public class SearchDemo03 {
    //二分查找的查找次数太多，当我查找第一个后最后一个值是会造成过多的查找次数
//    插值查找算法：快速定位
    public static void main(String[] args) {
        int[] array = new int[67];
        for (int i = 0; i <67 ; i++) {
            array[i]=i;
        }
        System.out.println(interpolationSearch(array, 0, array.length - 1, 66));

        System.out.println(SearchDemo02.binarySearch(array, 66, 0, array.length - 1));


    }
    public static int interpolationSearch(int[] array,int left,int right,int value){
        System.out.println("插值查找查找了一次");
        if (left>right||value>array[right]||value<array[left]){
            return -1;
        }else {
            int mid=left+(right-left)*(value-array[left])/(array[right]-array[left]);
            if (value>array[mid]){
               return interpolationSearch(array, mid+1, right, value);
            }if (value<array[mid]){
                return interpolationSearch(array, left, mid-1, value);
            }
            return mid;
        }
    }
}

斐波那契查找算法（黄金分割法）：

package com.model.search;

import java.util.Arrays;

/**
 * @Description:测试类
 * @Author: 张紫韩
 * @Crete 2021/7/12 19:42
 * 查找算法：
 * 斐波那契查找算法（黄金分割算法）：Fibonacci search
 */
public class SearchDemo04 {
    public static void main(String[] args) {
        int[] fib = fib(10);
        System.out.println(Arrays.toString(fib));

        int[] array={1,8,10,89,1000,1234};
        System.out.println("index="+fibSearch(array,89));

    }
    public static int fibReturn(int n){
        if (n==0||n==1){
            return 1;
        }else {
            return fibReturn(n-1)+fibReturn(n-2);
        }
    }

    public static int[] fib(int max){
        int[] fib = new int[max];
        for (int i = 0; i < max; i++) {
            fib[i]=fibReturn(i);
        }
        return fib;
    }

    public static int fibSearch(int[] array,int value){
        int low=0;
        int high=array.length-1;
        int k=0;
        int mid=0;
        int f[]=fib(30);
        while (high>f[k]-1){
            k++;
        }
        int[] temp=Arrays.copyOf(array, f[k]);
        for (int i = high+1; i <temp.length ; i++) {
            temp[i]=array[high];
        }
        while(low<=high){
            mid=low+f[k-1]-1;
            if (value<temp[mid]){
                high=mid-1;
                k--;
            }else if (value>temp[mid]){
                low=mid+1;
                k-=2;
            }else {
                if (mid<=high){
                    return mid;
                }else {
                    return high;
                }
            }
        }
        return -1;
    }

}