[java]-算法与数据结构-第八章-查找算法

文章目录

• 八、查找算法
• • 1. 顺序（线性）查找算法
  • 2. 二分查找
  • • 1）思路分析
    • 2）代码实现
  • 3. 插值查找算法
  • • 1）原理介绍
    • 2）代码
  • 4. 斐波那契（黄金分割法）
  • • 1）介绍
    • 2）原理
    • 3）代码

八、查找算法 1. 顺序（线性）查找算法

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

2. 二分查找 1）思路分析

1. 首先确定该数组的中间的下标

   mid= (left+right)/2

2. 然后让需要查找的数findval和arr[mid]比较

   • findval > arr[mid]，说明你要查找的数在mid的右边,因此需要递归的向右查找2.2
   • findyal
   • findval ==arr[mid]说明找到，就返回

3. /什么时候我们需要结束递归

   • 找到就结束递归
   • 递归完整个数组，仍然没有找到findval，也需要结束递归当left > right就需要退出

2）代码实现

    // 递归
    public static int binarySearch(int arr[], int min, int max, int findVal) {
        if (min > max) {
            return -1;
        }
        int mid = (min + max) / 2;
        int midVal = arr[mid];

        if (findVal > midVal) { // 向右
            return binarySearch(arr, mid + 1, max, findVal);
        } else if (findVal < midVal) {
            return binarySearch(arr, min, mid - 1, findVal);
        } else {
            return mid;
        }
    }
    
    // 不用递归
        // 循环
    public static int binarySearch2(int arr[], int findVal) {

        int min = 0;
        int max = arr.length - 1;
        while (true) {
            int mid = (max + min) / 2;
            if (findVal == arr[mid]) {
                return mid;
            } else if (findVal > arr[mid]) {
                min = mid;
            } else {
                max = mid;
            }
        }
    }

3. 插值查找算法 1）原理介绍

2）代码

• 代码

public static int insertSearch(int[] arr, int findValue) {
        int min = 0;
        int max = arr.length - 1;
        int count = 0;
        int mid = 0;
        while (true) {
            count++;

            mid =  min +  (max - min) * (findValue - arr[min]) / (arr[max] - arr[min]);
            if (min > max || findValue < arr[0] || findValue > arr[arr.length - 1]) {
                break;
            }
            if (arr[mid] == findValue) {
               break;
            }
            if (arr[mid] > findValue) {
                min = mid + 1;
            }
            if (arr[mid] < findValue) {
                max = mid - 1;
            }
        }
        System.out.println(count);
        return mid;
    }

4. 斐波那契（黄金分割法） 1）介绍

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

2）原理

斐波那契查找原理与前两种相似，仅仅改变了中间结点(mid）的位置，mid不再是中间或插值得到，而是位于黄金分割点附近，

即mid=low+F(k-1)-1(F代表斐波那契数列)

1. 由斐波那契数列F[K]=F[k-1]+F[k-2]的性质，可以得到（F[k]-1)=(F[k-1]-1)+(F[k-2]-1)+1。

   该式说明:只要顺序表的长度为F[k]-1，则可以将该表分成长度为F[k-]-1和F[k-2]-1的两段，

   即如上图所示。从而中间位置为mid=low+F(k-1)-1

2. 类似的，每一子段也可以用相同的方式分割

3. 但顺序表长度n不一定刚好等于F[K]-1，所以需要将原来的顺序表长度n增加至F[K-1]。这里的k值只要能使得F[k]-1恰好大于或等于n郎可，由以下代码得到,顺序表长度增加后，新增的位置从n+1到F[k]-1位置)，都赋为n位置的值即可。

3）代码

public class 斐波那契查找 {
    public static void main(String[] args) {
        int[] arr = {1, 8, 10, 89, 1000, 1234};
        System.out.println(fibSearch(arr, 89));
    }

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

     public static int fibSearch(int[] arr, int key) {
        //数组左侧索引
        int low = 0;
        //数组右侧索引
        int high = arr.length - 1;
        //比右侧索引大的第一个斐波那契数对应的索引
        int k = 0;
        //黄金分割点
        int mid = 0;
        //斐波那契数列
        int[] f = fib();
        //由数组最大值计算k
        while (high > f[k] - 1) {
            k++;
        }

        //因为f[k]的值可能大于数组的长度，因此需要给原数组扩容到长度 == f(k)
        int[] tmp = Arrays.copyOf(arr, f[k]);
        //调用copyOf方法后在扩容部分全部补了0，实际上需要补数组的最后一位
        for (int i = high + 1; i < tmp.length; i++) {
            tmp[i] = arr[high];
        }
        //使用while循环来查找需要找的数
        while (low <= high) {
            //先计算黄金分割点
            mid = low + f[k - 1] - 1;
            //判断黄金分割点的元素和要查找的元素的关系
            //如果要查找的值在mid左边，重置high和k
            if (tmp[mid] > key){
                high = mid - 1;
                k--;
                //如果要查找的值在mid右边
            }else if (tmp[mid] < key){
                low = mid + 1;
                k -= 2;
                //否则找到该元素
            }else {
                if (mid <= high){
                    return mid;
                }else {
                    return high;
                }
            }
        }
        //如果循环结束后还没有找到，说明没有
        return -1;
     }

---