算法基础11：查找算法

线性查找算法

从线性数列中的起始位置依次比较判断数列中是否包含需要查找的数，若找到了直接返回下标

代码

public class SeqSearch {

    public static void main(String[] args) {
        int[] arr = {1, 4, 7, 2, 3, 9};
        int search = seqSearch(arr, 7);
        if (search == -1){
            System.out.println("没有找到");
        }else {
            System.out.println("找到了");
        }
    }

    /**
     * 这里我们实现的线性查找是找到一个满足条件的值，就返回
     * @param arr
     * @param value
     * @return
     */
    public static int seqSearch(int[] arr, int value) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == value) {
                return i;
            }
        }
        return -1;
    }
}

二分查找算法

查找的数组必须是有序的

思路

代码

/**
 * 二分查找
 *
 * @author：XMD
 * @date: 4.9.22
 */
public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {1, 3, 7, 8, 10, 12, 14, 16, 27};
        int search = binarySearch(arr, 0, arr.length - 1, 9);
        System.out.println(search);

    }

    /**
     * @param arr
     * @param left    左边的索引
     * @param right   右边的索引
     * @param findVal 要查找的值
     * @return 如果找到就返回下标，如果没有找到，就返回-1
     */
    public static int binarySearch(int[] arr, int left, int right, int findVal) {
        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 {
            return mid;
        }
    }
}

上面代码存在问题，如果有重复数据，只会返回一个

优化

/**
 * @param arr
 * @param left    左边的索引
 * @param right   右边的索引
 * @param findVal 要查找的值
 * @return 如果找到就返回下标，如果没有找到，就返回-1
 */
public static List<Integer> binarySearch2(int[] arr, int left, int right, int findVal) {
    if (left > right) {
        return new ArrayList<>();
    }
    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 {
        /*
        思路分析
        1。在找到mid索引值，不要马上返回
        2。向mid索引值的左边扫描，将所有满足查询数字，的元素的下标，加入到集合ArrayList
        3。向mid索引值的右边扫描，将所有满足查询数字，的元素的下标，加入到集合ArrayList
        4.将Arraylist返回
         */
        List<Integer> list = new ArrayList<>();
        //索引值的左边扫描，将所有满足查询数字，的元素的下标，加入到集合ArrayList
        int temp = mid - 1;
        while (true) {
            if (temp < 0 || arr[temp] != findVal) {
                break;
            }
            //否则，就temp放入到list
            list.add(temp);
            temp--;
        }
        list.add(mid);

        //向mid索引值的右边扫描，将所有满足查询数字,的元素的下标，加入到集合ArrayList
        temp = mid + 1;
        while (true) {
            if (temp > arr.length - 1 || arr[temp] != findVal) {
                break;
            }
            //否则，就temp放入到list
            list.add(temp);
            temp++;
        }
        return list;
    }

}

插值查找算法

公式：int mid = left + (right -left) * (findVal - arr[left]) / (arr[right] - arr[left])

代码

/**
 * 插值算法
 *
 * @author：XMD
 * @date: 5.9.22
 */
public class InsetValueSearch {
    public static void main(String[] args) {
        int[] arr = new int[20];
        for (int i = 0; i < 20; i++) {
            arr[i] = i + 1;
        }

        int search = insetValueSearch(arr, 0, arr.length - 1, 15);
        System.out.println(search);

    }

    /**
     * @param arr
     * @param left
     * @param right
     * @param findVal
     * @return
     */
    public static int insetValueSearch(int[] arr, int left, int right, int findVal) {
        System.out.println("WWWWWW");
        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 insetValueSearch(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) {
            //向右递归
            return insetValueSearch(arr, left, mid - 1, findVal);
        } else {
            return mid;
        }

    }
}

注意事项

• 对于数据量较大，关键字分布比较均匀的查找表来说，采用插值查找，速度较快.
• 关键字分布不均匀的情况下，该方法不一定比折半查找要好

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

1. 黄金分割点是指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比。取其前三位数字的近似值是0.618。由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中外比。这是一个神奇的数字，会带来意向不大的效果。
2. 斐波那契数列{1,1,2,3,5,8,13,21,34,55}发现斐波那契数列的两个相邻数的比例，无限接近黄金分割值0.618

工作原理

斐波那契查找应用案例
请对一个有序数组进行斐波那契查找{1,8,10,89,1000,1234}，输入一个数看看该数组是否存在此数，并且求出下标，如果没有就提示"没有这个数

代码

import java.util.Arrays;

/**
 * 斐波那契查找算法
 *
 * @author：XMD
 * @date: 5.9.22
 */
public class FibonacciSearch {
    public static int maxSize = 20;

    public static void main(String[] args) {
        int[] arr = {1, 8, 10, 89, 1000, 1234};
//        int[] fibo = fibo();
//        System.out.println(Arrays.toString(fibo));

        int search = fibSearch(arr, 10);
        System.out.println(search);
    }

    //因为后面我们mid=1ow+F(k-1)-1,需要使用到斐波那契数列，因此我们需要先获取到一个斐波那契数列
    //非递归方法得到一个斐波那契数列
    public static int[] fibo() {
        int[] fb = new int[maxSize];
        fb[0] = 1;
        fb[1] = 1;
        for (int i = 2; i < maxSize; i++) {
            fb[i] = fb[i - 1] + fb[i - 2];
        }
        return fb;
    }

    /**
     * 编写斐波那契查找算法
     * 使用非递归的方式编写算法
     *
     * @param arr
     * @param key
     * @return
     */
    public static int fibSearch(int[] arr, int key) {
        int low = 0;
        int high = arr.length - 1;
        //表示斐波那契分割数值的下标
        int k = 0;
        int mid;
        //获取到斐波那契数列
        int[] f = fibo();
        //获取到斐波那契分割数值的下标
        while (high > f[k] - 1) {
            k++;
        }
        ///因为f[k]值可能大于a的长度，因此我们需要使用Arrays类，构造一个新的数组，并指向temp[]
        int[] temp = Arrays.copyOf(arr, f[k]);

        //实际上需求使用a数组最后的数填充temp
        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]的前面继续查找k--
                //即下次循环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]
                //3.因为后面我们有f[k-2]所以可以继续拆分f[k-1]=f[k-3]+f[k-4]
                //4。即在f[k-2]的前面进行查找k-=2
                //5,即下次循环mid=f[k-1-2]-1
                 */
                k -= 2;
            } else {
                //需要确定，返回的是娜个下标
                if (mid <= high) {
                    return mid;
                } else {
                    return high;
                }
            }
        }
        return -1;
    }
}

有点难理解