查找算法

 

 

查找算法介绍

1) 顺序(线性)查找

2) 二分查找/折半查找

3) 插值查找

4) 斐波那契查找

 

线性查找

从头到尾遍历

package com.example.demo1.dataStructure.search;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author liangqing
 * @since 2021/2/5 9:32
 */
public class SeqSearch {

    private final static AtomicInteger atomicInteger = new AtomicInteger(0);

    public static void main(String[] args) {
        int[] arr = {1, 9, 11, -1, 34, 89};
        seqSearch(arr, 89);
    }

    public static int seqSearch(int[] a, int num) {

        for (int i = 0; i < a.length; i++) {
            atomicInteger.incrementAndGet();
            if (a[i] == num) {
                System.out.println("遍历次数" + atomicInteger.get());
                return i;
            }
        }
        System.out.println("遍历次数" + atomicInteger.get());
        return -1;
    }
}

二分查找

思路

代码

private final static AtomicInteger atomicInteger = new AtomicInteger(0);

/**
 * 二分查找，只有一个数的情况
 *
 * @param a
 * @param left
 * @param right
 * @param num
 * @return
 */
public static int binarySearch(int[] a, int left, int right, int num) {
    atomicInteger.incrementAndGet();

    //需要考虑找不到的情况
    if (left > right) {
        return -1;
    }
    //获取中间位置
    int middle = (left + right) / 2;
    if (num > a[middle]) {
        return binarySearch(a, middle + 1, right, num);
    } else if (num < a[middle]) {
        return binarySearch(a, left, middle - 1, num);
    } else {
        //返回位置，最终返回的结果都在此处
        return middle;
    }
}

 

二分查找增强版

private final static AtomicInteger atomicInteger = new AtomicInteger(0);

/**
 * 查找所有有效的数据 多个数的情况
 *
 * @param a
 * @param left
 * @param right
 * @param num
 * @return
 */
public static List<Integer> binarySearchAll(int[] a, int left, int right, int num) {
    atomicInteger.incrementAndGet();

    //需要考虑找不到的情况
    if (left > right) {
        return new ArrayList<>();
    }
    //获取中间位置
    int middle = (left + right) / 2;
    int temp;
    if (num > a[middle]) {
        return binarySearchAll(a, middle + 1, right, num);
    } else if (num < a[middle]) {
        return binarySearchAll(a, left, middle - 1, num);
    } else {
        //返回位置，最终返回的结果都在此处
        List<Integer> result = new ArrayList<>();
        result.add(middle);
        temp = middle - 1;
        //先向左侧查找
        while (temp > left && a[temp] == a[middle]) {
            result.add(temp);
            temp--;
        }

        //再向右侧查找
        temp = middle + 1;
        while (temp < right && a[temp] == a[middle]) {
            result.add(temp);
            temp++;
        }
        return result;
    }
}

 

插值查找

思路

1) 插值查找原理介绍:

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

2) 将折半查找中的求 mid 索引的公式 , low 表示左边索引 left, high 表示右边索引 right.

key 就是前面我们讲的 findVal

3) int mid = low + (high - low) * (key - arr[low]) / (arr[high] - arr[low]) ;/*插值索引*/

对应前面的代码公式：

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

4) 举例说明插值查找算法 1-100 的数组

package com.example.demo1.dataStructure.search;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author liangqing
 * @since 2021/2/5 9:54
 * 插值查找算法类似于二分查找，不同的是插值查找每次从自适应 mid 处开始查找
 * 由二分查找 公式推断出来
 * int mid = left + (right – left) * (findVal – arr[left]) / (arr[right] – arr[left])
 */
public class InsertValueSearch {

    private final static AtomicInteger atomicInteger = new AtomicInteger(0);

    public static void main(String[] args) {
        int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        System.out.println(insertValueSearch(arr, 0, 9, 8));
        System.out.println("总共查找了" + atomicInteger.get());
    }

    public static int insertValueSearch(int[] a, int left, int right, int num) {
        atomicInteger.incrementAndGet();

        //需要考虑找不到的情况
        if (left > right) {
            return -1;
        }
        //获取中间位置
        int middle = left + (right - left) * (num - a[left]) / (a[right] - a[left]);
        if (num > a[middle]) {
            return insertValueSearch(a, middle + 1, right, num);
        } else if (num < a[middle]) {
            return insertValueSearch(a, left, middle - 1, num);
        } else {
            //返回位置，最终返回的结果都在此处
            return middle;
        }
    }
}

 

斐波那契查找

介绍

1) 黄金分割点是指把一条线段分割为两部分，使其中一部分与全长之比等于另一部分与这部分之比。取其前三位数字的近似值是 0.618。由于按此比例设计的造型十分美丽，因此称为黄金分割，也称为中外比。这是一个神奇的数字，会带来意向不大的效果。

2) 斐波那契数列 {1, 1, 2, 3, 5, 8, 13, 21, 34, 55 } 发现斐波那契数列的两个相邻数 的比例，无限接近 黄金分割值0.618

斐波那契(黄金分割法)原理:

斐波那契查找原理与前两种相似，仅仅改变了中间结点（mid）的位置，mid 不再是中间或插值得到，而是位于黄金分割点附近，即 mid=low+F(k-1)-1（F 代表斐波那契列），如下图所示

对 F(k-1)-1 的理解：

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]-1 和位置为 mid=low+F(k-1)-1

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

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

while(n>fib(k)-1)

k++;