数据结构查找算法

1、二分查找

1）二分查找精髓思想是从中间开始查找向左向右扫描，然后再递归查找到下标

2）binarySearch是找到一个值就返回这个最先找到的下标的方法

3）binarySearch是找到所有符合值的下标装进集合中返回

package Search;

import java.util.ArrayList;
import java.util.List;

/**
 * 二分查找
 * 使用二分查找的前提是数组是有序的
 */
public class BinarySearch {
    public static void main(String[] args) {
        int arr[] = { 1, 8, 10, 89,1000, 1000,1000,1000,1234 };

//        int resIndex = binarySearch(arr, 0, arr.length - 1, 1000);
//        System.out.println("下标是："+resIndex);
        List<Integer> resIndexList = binarySearch2(arr, 0, arr.length - 1,1000);
        System.out.println("resIndexList"+resIndexList);
    }

    /**
     * 二分查找算法
     * @param arr 数组
     * @param left 左边索引
     * @param right 右边索引
     * @param findVal 查找的值
     * @return
     */
    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,left,mid - 1,findVal);
        }else if(findVal > midVal){
            return binarySearch(arr,mid+1,right,findVal);
        }else {
            return mid;
        }
    }

    /**
     * 优化二分查找
     * 课后思考题： {1,8, 10, 89, 1000, 1000，1234} 当一个有序数组中，
     * 有多个相同的数值时，如何将所有的数值都查找到，比如这里的 1000
     *
     * 思路分析
     * 1. 在找到mid 索引值，不要马上返回
     * 2. 向mid 索引值的左边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
     * 3. 向mid 索引值的右边扫描，将所有满足 1000， 的元素的下标，加入到集合ArrayList
     * 4. 将Arraylist返回
     */
    public static List<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,left,mid - 1,findVal);
        }else if(findVal > midVal){
            return binarySearch2(arr,mid+1,right,findVal);
        }else {
            List<Integer> list = new ArrayList<Integer>();
            int temp = mid - 1;
            while(true){
                if(temp < 0 || arr[temp] != findVal){
                    break;
                }
                list.add(temp);
                temp -= 1;
            }
            list.add(mid);

            temp = mid + 1;
            while(true){
                if(temp > arr.length - 1 || arr[temp] != findVal){
                    break;
                }
                list.add(temp);
                temp += 1;
            }

            return list;
        }
    }
}

2、插值查找

插值查找主要了利用了自适应公式，找到距离查找值最近的地方，然后减少递归次数提升效率

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

package Search;

import java.util.Arrays;

/**
 * 插值查找
 * 主要在二分查找的基础上优化了mid自适应性
 */
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;
        }

        //System.out.println(Arrays.toString(arr));

        int resIndex = insertValueSearch(arr, 0, arr.length - 1, 100);
        System.out.println("resIndex：" + resIndex);
    }

    public static int insertValueSearch(int[] arr, int left, int right, int findVal) {
        //findVal < arr[0] || findVal > arr[arr.length - 1]不仅仅是优化，也防止了越界问题
        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 (midVal > findVal) {
            return insertValueSearch(arr, left, mid - 1, findVal);
        } else if (midVal < findVal) {
            return insertValueSearch(arr, mid + 1, right, findVal);
        } else {
            return mid;
        }
    }
}

3、斐波那契查找

斐波那契数列相对比较难理解，可以借阅大话数据结构进行解析

package Search;

public class FibonacciSearch {
    public static int maxSize = 20;

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

    }

    /**
     * 创造斐波那契数列
     * 使用非递归的方式
     *
     * @return
     */
    public static int[] fib() {
        int[] fib = new int[maxSize];
        fib[0] = 1;
        fib[1] = 1;
        for (int i = 2; i < maxSize; i++) {
            fib[i] = fib[i - 1] + fib[i - 2];
        }

        return fib;
    }

    /**
     * 斐波那契查找算法
     *
     * @param a   需要查找的数组
     * @param n   记录末位
     * @param key 查找的值
     * @return
     */
    public static int fibonacciSearch(int[] a, int n, int key) {
        int low = 0;
        int high = n;
        int k = 0;// k用来记录此时查找的下标
        int mid = 0;
        int[] F = fib();
        int[] copy = new int[maxSize];
        for (int i = 0; i < a.length; i++) {
            copy[i] = a[i];
        }
        while (n > F[k] - 1) { //计算n位于斐波那契数列的位置（就可以找到帮助找到k值）
            k++;
        }
        for (int i = n; i < F[k] - 1; i++) {// 补充线性表
            copy[i] = a[n];
        }
        while (low <= high) {
            mid = low + F[k - 1] - 1;//计算分割的下标（找到黄金线性分割点）
            if (key < copy[mid]) {
                high = mid - 1;// 最高下标调整到分割下标的mid - 1处
                k -= 1;
            } else if (key > copy[mid]) {
                low = mid + 1;
                k -= 2;
            } else {
                if (mid <= n) {
                    return mid;// 找到下标刚好就是mid的值
                } else {
                    return n; // mid > n 即说明是补全的数值，返回就是最高末位
                }
            }
        }
        return -1;//没找到对应值
    }
}