第六话查找算法

最新推荐文章于 2024-09-09 15:48:17 发布

dong24k

最新推荐文章于 2024-09-09 15:48:17 发布

阅读量77

点赞数

分类专栏：老韩数据结构与算法文章标签：数据结构快速排序算法

本文链接：https://blog.csdn.net/dong24k/article/details/115751181

版权

老韩数据结构与算法专栏收录该内容

12 篇文章 3 订阅

订阅专栏

6. 查找算法

在java中我们常用的查找算法是：

顺序（线性）查找
二分查找/折半查找
插值查找
斐波那契查找

6.1 线性查找

代码实现

public class SeqSearch {
    public static void main(String[] args) {
        int[] arr = {1,9,11,-1,34,80};
        int index = seqSearch(arr,11);
        if (index == -1){
            System.out.println("没有找到");
        } else {
            System.out.println("找到了，下标为 "+index);
        }

    }
    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

6.2 二分查找

只针对有序数列查找

思路分析

首先确定该数组的中间的下标：mid=(left+right)/2
然后让需要查找的数findval和arr[mid]进行比较

2.1 findval > arr[mid]，说明你需要查找的数在mid的右边，因此需要递归的向右查找

2.2 findval < arr[mid]，说明你需要查找的数在mid的左边，因此需要递归的向左查找

2.3 find == arr[mid]，说明找到，直接返回
什么时候结束递归呢

3.1 找到就结束递归

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

6.2.1 二分查找的基本版

对于要查找的数据没有出现重复的现象

public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {1,8,10,89,1000,1234};
        int resIndex = binarySearch(arr,0,arr.length-1,1234);
        System.out.println("resIndex="+resIndex);

    }

    //二分查找算法
    public static int binarySearch(int[] arr,int left,int right,int findVal){

        //当left > right时，说明递归整个数组，但是没有找到
        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;
        }
    }
}

结果

resIndex=5

6.2.2 二分查找的高级版

public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {1, 8, 10, 89, 1000, 1000, 1000, 1234};
        List<Integer> resIndex = binarySearch2(arr, 0, arr.length - 1, 1000);
        System.out.println("resIndex=" + resIndex);

    }

    //二分查找算法
    public static int binarySearch(int[] arr, int left, int right, int findVal) {

        //当left > right时，说明递归整个数组，但是没有找到
        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;
        }
    }

    //将表中所有需要查找的数都找出来
    //1. 在找到mid索引值，不要马上返回
    //2. 向mid 索引值的左边扫描，将所有满足1000，的元素的下标加入到集合ArrayList
    //3. 向mid 索引值的右边扫描，将所有满足1000，的元素的下标加入到集合ArrayList
    //4. 将ArrayList返回
    public static ArrayList<Integer> binarySearch2(int[] arr, int left, int right, int findVal) {
        //当left > right时，说明递归整个数组，但是没有找到
        if (left > right) {
            return new ArrayList<Integer>();
        }
        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 {
            ArrayList<Integer> resIndexlist = new ArrayList<Integer>();
            //向mid 索引值的左边扫描，将所有满足1000，的元素的下标，加入到集合ArrayList
            int temp = mid - 1;
            while (true) {
                if (temp < 0 || arr[temp] != findVal) {
                    break;
                }
                //否则，将temp放入到resIndexList
                resIndexlist.add(temp);
                temp -= 1;
            }
            resIndexlist.add(mid);

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

    }
}

结果

resIndex=[4, 5, 6]

6.3 插值查找

6.3.1 插值查找的基本原理

插值查找算法类似于二分查找，不同的是插值查找每次从自适应mid开始查找

关于mid的定义如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NllThBHL-1618541531991)(C:\Users\dongwei\AppData\Roaming\Typora\typora-user-images\image-20210331082304226.png)]

插值查找算法的举例说明

数组arr = [1,2,3,…,100]

假如我们要查找的是1

使用二分查找的话需要多此递归，才能找到1

使用插值查找算法

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

int mid = 0 + (99 - 0)*(1 - 1)/(100 - 1) = 0

同理我们如果找的是100则

int mid = 0 + (99 - 0)*(100 - 1)/(100 - 1) = 99

6.3.2 插值查找的代码实现

public class InsertValueSearch {
    public static void main(String[] args) {
        int[] arr = new int[100];
        for (int i = 0; i < 100; i++) {
            arr[i] = i + 1;
        }
        int index = insertVlaueSearch(arr, 0, arr.length - 1, 10);
        System.out.println("index = " + index);
    }

    //编写插值算法的
    //说明：插值查找算法，也是要求数组是有序的
    public static int insertVlaueSearch(int[] arr, int left, int right, int findVal) {
        System.out.println("~~~~~~~~");
        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 insertVlaueSearch(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) {
            return insertVlaueSearch(arr, left, mid - 1, findVal);
        } else {
            return mid;
        }
    }
}

结果

~~~~~~~~
index = 9

插值查找的注意事项

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

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

6.4.1 斐波那契查找的基本介绍

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SV9ttCaJ-1618541531995)(C:\Users\dongwei\AppData\Roaming\Typora\typora-user-images\image-20210331091714277.png)]

6.4.2 代码实现

public class FibonacciSearch {
    public static int maxSize = 20;

    public static void main(String[] args) {
        int[] arr = {1, 8, 10, 89, 1000, 1234};
        System.out.println("index=" + fibSearch(arr, 1234));
    }

    //因为我们后面mid = low + F(k-1)-1，需要使用到斐波那契数列，因此我们直接创建一个斐波那契数列
    //非递归方法得到一个斐波那契数列
    public static int[] fib() {
        int[] f = new int[maxSize];
        f[0] = 1;
        f[1] = 1;
        for (int i = 2; i < maxSize; i++) {
            f[i] = f[i - 1] + f[i - 2];
        }
        return f;
    }

    //编写斐波那契查找算法
    //使用非递归的方式编写算法
    public static int fibSearch(int[] a, int key) {
        int low = 0;
        int high = a.length - 1;
        int k = 0; //表示斐波那契分割数值的下标
        int mid = 0; //存放mid值
        int f[] = fib(); //获取到斐波那契数列

        //获取到斐波那契分割数值的下标
        while (high > f[k] - 1) {
            k++;
        }

        //因为f[k]值可能大于a的长度，因此我们需要使用Arrays类，构造一个新的数组，并指向a[]
        //不足的部分使用0进行填充
        int[] temp = Arrays.copyOf(a, f[k]);
        //上面这一部分是将值进行0填补，但是我们希望的是将填补的数值转换为该数组的最高值
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = a[high];
        }
        //使用while循环处理，找到我们的数hey
        while (low <= high) {
            mid = low + f[k - 1] - 1;
            //只要满足这个条件，就可以开始找
            if (key < temp[mid]) {
                //此时我们应该继续向前找（左边）
                high = mid - 1;
                k--;
                /*
                 * 说明一下为什么是k--
                 * 1. 全部元素 = 前面的元素 + 后面的元素
                 * 2. f[k[ = f[k-1] + f[k-2]
                 * 3. 因为前面有f[k-1]个元素，所以可以继续拆分f[k-1] = f[k-2] + f[k-3]
                 * 即在f[k-1]前面继续查找k--
                 * */
            } else if (key > temp[mid]) {
                low = mid + 1;
                k -= 2;
                //因为后面我们有f[k-2] 所以可以继续拆分为f[k-1] = f[k-3] + f[k-4]
            } else {
                //找到了
                //需要确定我们需要返回的是哪个值
                if (mid <= high) {
                    return mid;
                } else {
                    return high;
                }
            }
        }
        return -1;
    }

}

index=5

6.4.3 难点理解

为什么后面需要k-2

mid的取值要求的是黄金分割点，意思就是说要保证mid之前的数字比例和mid之后的数字比例是0.618，我们是为了方便才设定了一个斐波那契数列，就是说这个数列已经将如何取值数组值得小标进行了规范，我们也可以自己去计算，但是直接从数组取值会更加的方便。

我们现在查找的数字排序如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h9uNt1xh-1618541531998)(C:\Users\dongwei\AppData\Roaming\Typora\typora-user-images\image-20210331141610229.png)]

按照第一步执行的我们找到了mid值为4

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N90JJREf-1618541532002)(C:\Users\dongwei\AppData\Roaming\Typora\typora-user-images\image-20210331142109251.png)]

但是此时我们需要往前走，这个时候会发现此时数据被分成两部分，

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S1CPauyd-1618541555219)(C:\Users\dongwei\AppData\Roaming\Typora\typora-user-images\image-20210331142413032.png)]

此时我们拿出斐波那契数列按照之前的八个数据，我们得到的数列是：1，1，2，3，5，8

此时第一部分对应的是 5 ，第二部分对应的是 3 。这样我们在进入第二部分判定的时候，需要找出中值就是2。因为2/3才能保证是黄金分割点。其实就是往前面移动一位。

dong24k

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第六话查找算法

6. 查找算法在java中我们常用的查找算法是：顺序（线性）查找二分查找/折半查找插值查找斐波那契查找6.1 线性查找代码实现public class SeqSearch { public static void main(String[] args) { int[] arr = {1,9,11,-1,34,80}; int index = seqSearch(arr,11); if (index == -1){
复制链接

扫一扫