算法——二分查找算法_易语言 搜索算法

一、简介

介绍：二分查找，也称折半搜索，是一种在 有序数组 中 查找某一特定元素 的搜索算法。下面简单介绍其优缺点，以及编码实现。

优点：比较次数少，查找速度快，平均性能好。
缺点：必须有序是数组——因此首先需要排序，而在排序过程中，数组的插入和删除效率是较低的，这就降低了二分法的性能，解决是 平衡二叉树。

二、中间值索引的计算

说明：对应中间值索引的计算有两种算法，分别如下：

// 算法一
int mid = (low + high) / 2;

// 算法二
int mid = low + (high - low) / 2;
1
2
3
4
5

比较：这两种算法的结果是一样的。不过对于算法一，极端情况可能出现值溢出（即 low + high 的值大于了 int 类型的范围）。而算法二不会有这个情况。

三、编码实现

/**
 * 二分查找法
 *
 * @author xjf
 * @date 2020/8/28 10:26
 */
public class BinarySearch {

    public static void main(String[] args) {
        int[] arr = new int[]{1, 5, 20, 50, 56, 92, 101, 256, 400, 666, 888};
        int target = 101;

        int recursionIndex = binarySearchWithRecursion(arr, 0, arr.length - 1, target);
        System.out.println("目标值索引：" + recursionIndex + "        从数组中获取值：" + arr[recursionIndex]);

        int loopIndex = binarySearchWithLoop(arr, target);
        System.out.println("目标值索引：" + loopIndex + "        从数组中获取值：" + arr[loopIndex]);
    }

    /**
     * 二分查找法：使用递归实现
     *
     * @param arr 有序数组
     * @param low 数组最小索引
     * @param high 数组最大索引
     * @param target 目标：要查找的值
     * @return 目标值在数组中的索引
     */
    private static int binarySearchWithRecursion(int[] arr, int low, int high, int target){
        // 如果最小索引大于了最大索引，还是没找到值，则返回 -1
        if (low > high){
            return -1;
        }

        // 求中间索引
        int mid = low + (high - low) / 2;

        // 如果中间值比目标值大，则说明目标值在索引小的那一半边，继续从这部分进行二分查找
        if (arr[mid] > target){
            return binarySearchWithRecursion(arr, low, mid -1, target);
        }
        // 如果中间值比目标值小，则说明目标值在索引大的那一半边，继续从这部分进行二分查找
        if (arr[mid] < target){
            return binarySearchWithRecursion(arr, mid + 1, high, target);
        }

        // 目标值和中间索引对应的值相等时，返回目标值的索引
        return mid;
    }

    /**
     * 二分查找法，使用循环实现
     *
     * @param arr 有序数组
     * @param target 目标：要查找的值
     * @return 目标值在数组中的索引
     */
    private static int binarySearchWithLoop(int[] arr, int target){
        int low = 0;
        int high = arr.length - 1;

        while (low <= high){
            int mid = low + (high - low) / 2;

            if (arr[mid] > target){
                // 中间值大于目标值，在索引小的部分
                high = mid -1;
            }else if (arr[mid] < target){
                // 中间值小于目标值，在索引大的部分
                low = mid + 1;
            }else {
                // 找到目标值，返回索引
                return mid;
            }
        }

        // 数组中没有目标值
        return -1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80