10.查找算法

在java中，我们常用四种查找算法：

  1.顺序查找(线性)

  2.二分法/折半查找

  3.插值查找

  4.斐波那契查找

1.线性查找.

 

2.二分查找算法

二分查找：

对一个 进行二分查找{1,8,10,89,1000,1234},输入一个数，看看该数组是否存在此数，并且求出下标，如果没有就提示"没有这个数"  

样例：
public class BinarySearch {
    public static void main(String[] args) {
        int arr[] = {1, 8, 10, 89, 1000, 1234};
        int index = binarySearch(arr, 0, arr.length-1, 5);
        System.out.println("找到了，下标为：" + index);
    }

    /**
     * 二分查找算法
     *
     * @param arr         数组
     * @param left        左索引
     * @param right       右索引
     * @param searchValue 查找数字
     * @return 找到的元素下标, 没找到返回-1
     */
    public static int binarySearch(int[] arr, int left, int right, int searchValue) {
        //当左索引大于右索引时
        if (left > right) {
            return -1;
        }
        //找到中间位置下标
        int middle = (left + right) / 2;
        if (searchValue < arr[middle]) {
            //这里需要注意，middle-1，不这么操作会造成死递归
            return binarySearch(arr, left, middle-1, searchValue);
        } else if (searchValue > arr[middle]) {
            //这里需要注意，middle+1
            return binarySearch(arr, middle+1, right, searchValue);
        } else {
            return middle;
        }
    }
}

思考：在{1,8,10,89,1000,1000,1000,1000,1234}中输出1000的所有下标

 public static List binarySearch2(int[] arr, int left, int right, int searchValue) {
        //当左索引大于右索引时，没找到
        if (left > right) {
            return null;
        }
        //找到中间位置下标
        int middle = (left + right) / 2;
        if (searchValue < arr[middle]) {
            //这里需要注意，middle-1，不这么操作会造成死递归
            return binarySearch2(arr, left, middle - 1, searchValue);
        } else if (searchValue > arr[middle]) {
            //这里需要注意，middle+1
            return binarySearch2(arr, middle + 1, right, searchValue);
        } else {
            /*
                重点1：
                这里在返回之前向左，和向右扫描，拿到所有相同的数的下标
             */
            List<Integer> list = new ArrayList<>();
            list.add(middle);
            int i = middle;
            //向左找
            while (arr[i - 1] == searchValue) {
                list.add(i - 1);
                i -= 1;
            }
            //向右找
            i = middle;
            while (arr[i + 1] == searchValue) {
                list.add(i + 1);
                i += 1;
            }
            return list;
        }
    }

3.插值查找算法

 

示例：
public class InsertValueSearch {
    private static int count=1;
    public static void main(String[] args) {
        int[] arr = new int[100];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
        int index=insertValueSearch(arr,0,arr.length-1,1);
        System.out.println("找到了：index="+index);
    }

    /**
     * 二分查找算法
     *
     * @param arr         数组
     * @param left        左索引
     * @param right       右索引
     * @param searchValue 查找数字
     * @return 找到的元素下标, 没找到返回-1
     */
    public static int insertValueSearch(int[] arr, int left, int right, int searchValue) {
        System.out.println("第"+(count++)+"次查找..");
        //当左索引大于右索引时
        if (left > right || searchValue < arr[0] || searchValue > arr[arr.length - 1]) {
            return -1;
        }
        //这里的下标按照这个公式来查找
        int middle = left + (right + left) * (searchValue - arr[left]) / (arr[right] - arr[left]);
        if (searchValue < arr[middle]) {
            //这里需要注意，middle-1，不这么操作会造成死递归
            return insertValueSearch(arr, left, middle - 1, searchValue);
        } else if (searchValue > arr[middle]) {
            //这里需要注意，middle+1
            return insertValueSearch(arr, middle + 1, right, searchValue);
        } else {
            return middle;
        }
    }
}

测试：
    线性的数组中，找几都是一次找到，但是必须是线性增加的数组..

插值查找的注意事项:

  1.对于数据量较大关键字分布比较均匀的查找表来说，采用插值查找速度较快。  

  2.关键字分布不均匀的情况下，该方法不一定比折半查找要好。

 

斐波那契(黄金分割法)查找算法

简介：

  

当解析到公式为：

  (f[k]-1)=(f[k-1]-1)+(f[k-2]-1)+1 并且顺序表的长度为f[k]-1时

发现等式分为三部分：f[k-1]-1     f[k-2]-1     1

最后的1就是mid，对照图比可以理解!

如果队列长度不是刚好的f[k]-1呢，参考截图3  

从而得到:mid=low+f[k-1]-1.

/**
 * 斐波那契查找算法
 * 借助额外数组(斐波那契数组：前两个元素的和等于第三个数组)来找到中间点
 */
public class FibonacciSearch {
    public static void main(String[] args) {
        int[] arr = {1, 9, 11, 18, 90, 91};
        System.out.println("原数组：" + Arrays.toString(arr));
        int index = fibSearch(arr, 18);
        System.out.println("index=" + index);
    }

    /**
     * 获取一个斐波那契数组
     *
     * @return 斐波那契数组
     */
    public static int[] fib() {
        int[] arr = new int[20];
        arr[0] = 1;
        arr[1] = 1;
        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        return arr;
    }

    /**
     * 借助斐波那契数组查找下标
     *
     * @param arr 查找数组
     * @param key 查找的值
     * @return 下标
     */
    public static int fibSearch(int[] arr, int key) {
        int low = 0;
        int high = arr.length - 1;
        //表示斐波那契分割数值的下标
        int k = 0;
        //存放mid值
        int mid = 0;
        //获取斐波那契数组
        int f[] = fib();
        /*
            获取斐波那契分割值下标
            根据上述的推导公式得：
                1.f[k]=f[k-1]+f[k-2];
                    左边的等式-1，右边减两个1，再加一
                2.f[k]-1=(f[k-1]-1)  +  (f[k-2]-1)  +1
                3.当前提条件，顺序表的长度==f[k]-1时，可以将其分为三部分
                    1:f[k-1]-1
                    2:f[k-2]-1
                    3:后面加的1，这个1就是中间的mid
                4.mid=low+f[k-1]-1
         */
        System.out.println("斐波那契数组：" + Arrays.toString(f));
        while (high > f[k] - 1) {
            k++;
        }
        System.out.println("斐波那契-index:" + k + " value=" + f[k]);
        //因为f[k]的值可能大于arr的长度，因此将多出的部分以arr最后一个元素填充
        int[] temp = Arrays.copyOf(arr, f[k]);//将数组扩充到f[k]大小，然后填充值
        //例如：temp={1,2,3,0,0,0}--->{1,2,3,3,3,3}
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = arr[high];
        }
        System.out.println("转换后数组：" + Arrays.toString(temp));
        //通过while循环找到我们的数key
        while (low <= high) {
            mid = low + f[k - 1] - 1;
            System.out.println("mid:" + mid);
            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=low+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]
                 */
                k -= 2;
            } else {
                //找到了
                if (mid <= high) {
                    return mid;
                } else {
                    return high;
                }
            }
        }
        return -1;
    }
}

测试输出：
    原数组：[1, 9, 11, 18, 90, 91]
    斐波那契数组：[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
    斐波那契-index:5 value=8
    转换后数组：[1, 9, 11, 18, 90, 91, 91, 91]
    mid:4
    mid:2
    mid:3
    index=3

 重点总结：通过额外创建一个数组：斐波那契数组，根据其特性去查找mid