线性查找

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

    /**
     * 线性查找,找到一个满足条件的值就返回
     */
    public static int serSearch(int[] arr, int value) {
        // 线性查找是逐一对比,发现有相同的值,就返回下标
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == value) {
                return i;
            }
        }
        return -1;
    }
}

二分查找

二分查找是一种查询效率非常高的查找算法。又称折半查找。

算法思想: 对有序的序列,每次都是以序列的中间位置的数来与待查找的关键字进行比较,每次缩小一半的查找范围,直到匹配成功。

注意: 使用二分查找的前提是数据是有序的。

查值索引的计算公式为: mid = (low + high) / 2

递归实现二分查找

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, 1234);
        System.out.println("查找到的下标为: " + (index == -1 ? "没有找到该数据" : index));
    }

    /**
     * 二分查找
     *
     * @param arr     数组
     * @param left    左边的索引
     * @param right   右边的索引
     * @param findVal 要查找的值
     * @return 如果找到就返回下标, 否则返回-1
     */
    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;
        }
    }
}

非递归实现二分查找

public class BinarySearchNoRecur {
    public static void main(String[] args) {
        int[] arr = {1, 3, 8, 10, 11, 67, 100};
        int index = binarySearch(arr, 67);
        System.out.println(index);
    }

    /**
     * @param arr    待查找的数组, arr是升序排序
     * @param target 要查找的数
     */
    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] > target) {
                // 向左边查找
                right = mid - 1;
            } else {
                // 向右边查找
                left = mid + 1;
            }
        }
        return -1;
    }
}

插值查找

基于二分查找算法,将查找点的选择改进为自适应选择,可以提高查找效率。插值查找也属于有序查找。

注: 对于表长较大,而关键字分布又比较均匀的查找表来说,插值查找算法的平均性能比折半查找要好的多。反之,数组中如果分布非常不均匀,那么插值查找未必是很合适的选择。

插值索引的计算公式为: int mid = low + (high - low) * (key - arr[low]) / (arr[high] - arr[low]);

代码示例:

public class InsertValueSearch {
    public static void main(String[] args) {
        int[] arr = new int[100];

        for (int i = 0; i < arr.length; i++) {
            arr[i] = i + 1;
        }
        System.out.println(Arrays.toString(arr));
        insertValueSearch(arr, 0, arr.length - 1, 66);
    }

    /**
     * 插值查找
     *
     * @param arr     数组
     * @param left    左边索引
     * @param right   右边索引
     * @param findVal 要查找的值
     * @return 找到返回下标, 没有找到返回-1
     */
    public static int insertValueSearch(int[] arr, int left, int right, int findVal) {
        if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) {
            return -1;
        }
        // 求出mid
        int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
        int midVal = arr[mid];
        if (findVal > midVal) {
            // 说明应该向右边递归查找
            return insertValueSearch(arr, mid + 1, right, findVal);
        } else if (findVal < midVal) {
            // 说明应该向左边递归查找
            return insertValueSearch(arr, left, mid - 1, findVal);
        } else {
            return mid;
        }
    }
}

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

由于博主暂时没能理解透彻,就不误导大家了,感兴趣的话可以自己查找,示例代码如下:

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(fibSearch(arr, 89));
    }

    /**
     * 因为后面 mid = low + F(k - 1) - 1,
     * 需要使用到斐波那契数列,因此需要先获取到一个斐波那契数列
     * 非递归方法得到一个斐波那契数列
     *
     * @return
     */
    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;
    }

    /**
     * 斐波那契查找算法
     * 使用非递归的方式
     *
     * @param a   数组
     * @param key 需要查找的关键码(值)
     * @return 返回对应的下标, 没有返回-1
     */
    public static int fibSearch(int[] a, int key) {
        int low = 0;
        int high = a.length - 1;
        // k表示斐波那契分割数值的下标
        int k = 0;
        // 存放mid值
        int mid = 0;
        // 获取到斐波那契数列
        int f[] = fib();
        // 获取到斐波那契分割数值的下标
        while (high > f[k] - 1) {
            k++;
        }
        // 因为 f[k] 值 可能大于 a 的长度,因此需要使用Arrays类,构造一个新的数组,并指向temp[]
        // 不足的部分会使用0填充
        int[] temp = Arrays.copyOf(a, f[k]);
        // 需要使用a数组最后的数填充temp
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = a[high];
        }
        // 使用while循环来处理,找到key
        while (low <= high) {
            // 只要这个条件满足,就可以找
            mid = low + f[k - 1] - 1;
            if (key < temp[mid]) {
                // 说明我们应该继续向数组的前面查找(左边)
                high = mid - 1;
                /*
                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 = f[k-1-1]-1
                 */
                k--;
            } else if (key > temp[mid]) {
                // 向后面查找(右边)
                low = mid + 1;
                /*
                1. 全部元素 = 前面的元素 + 后边的元素
                2. f[k] = f[k - 1] + f[k - 2]
                3. 因为后面有 f[k - 2], 所以可以继续拆分 f[k - 1] = f[k - 3] + f[k - 4]
                4. 即在 f[k - 2] 的前面进行查找 k-=2
                即下次循环 mid = f[k - 1 - 2] - 1
                 */
                k -= 2;
            } else {
                // 找到了,需要确定返回的是哪个下标
                if (mid <= high) {
                    return mid;
                } else {
                    return high;
                }
            }
        }
        return -1;
    }

}