[053] Java“二分查找算法”

1、二分查找

• Binary Search：又称为折半查找，相比于顺序遍历查找，使用二分查找算法的效率更高，但要求数组有序；
• 步骤：
  • ① 确保数组有序，求得数组的中间值所在索引 mid = (left + right) / 2；
  • ② 将中间值midVal与查找值searchVal比较，如果 midVal == searchVal，说明找到结果，返回索引；
  • ③ 如果 searchVal > midVal，就向右继续二分查找，即：将 mid+1 作为左边界，右边界不动，递归使用二分查找算法；
  • ④ 如果 searchVal < midVal，就向左继续二分查找，即：将 mid -1 作为右边界，左边界不动，递归使用二分查找算法；
  • ⑤ 递归终止条件：midVal == searchVal  或者 左边界 > 右边界；

2、Java代码

// 二分查找算法
package Algorithm.Search;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * @author yhx
 * @date 2020/10/09
 */
public class BinarySearch {
    private static final int NUM = 20;
    public static void main(String[] args) {
        int[] arr = new int[NUM];
        for (int i = 0; i < NUM; i++) {
            arr[i] = i + 1;
        }
        int findVal = 19;
        // 二分查找的前提是数组有序，所以要先做排序处理
        Arrays.sort(arr);
        System.out.println("数组排序后 arr = " + Arrays.toString(arr));
        Binary binary = new Binary();
        ArrayList<Integer> resIndex = binary.binary(arr, 0, arr.length - 1, findVal);
        if (resIndex.size() == 0) {
            System.out.println("抱歉，数组中未找到" + findVal);
        } else {
            System.out.println("匹配值的下标有：" + resIndex);
        }
    }
}

class Binary {
    /**
     * @param arr     查找的数组
     * @param left    数组的左下标
     * @param right   数组的右下标
     * @param findVal 要查找的数
     * @return 返回查找数的下标
     */
    public ArrayList<Integer> binary(int[] arr, int left, int right, int findVal) {
        System.out.println("打印几次就递归几次");
        // 当left > right，说明没找到，直接返回空数组
        if (left > right || findVal < arr[0] || findVal > arr[arr.length - 1]) {
            return new ArrayList<>();
        }
        int mid = (left + right) / 2;
        //int mid = left + (right - left) * (findVal - arr[left]) / (arr[right] - arr[left]);
        int midVal = arr[mid];
        // 向右递归
        if (findVal > midVal) {
            return binary(arr, mid + 1, right, findVal);
        }
        // 向左递归
        else if (findVal < midVal) {
            return binary(arr, left, mid - 1, findVal);
        }
        // 返回结果
        else {
            /*
            当找到一个匹配值的下标mid时，不要立即返回，可能还有多个匹配值
            要向mid的左和右扫描，加入到ArrayList数组再返回
             */
            ArrayList<Integer> resIndexList = new ArrayList<>();
            // 向左扫描
            int temp = mid - 1;
            while (true) {
                if (temp < 0 || arr[temp] != findVal) {
                    break;
                } else {
                    resIndexList.add(temp);
                    // 继续左移
                    temp--;
                }
            }
            // 把中间值添加到集合中
            resIndexList.add(mid);
            // 向右扫描
            temp = mid + 1;
            while (true) {
                if (temp > arr.length - 1 || arr[temp] != findVal) {
                    break;
                } else {
                    resIndexList.add(temp);
                    // 继续右移
                    temp++;
                }
            }
            return resIndexList;
        }
    }
}

3、运行结果

数组排序后 arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
打印几次就递归几次
打印几次就递归几次
打印几次就递归几次
打印几次就递归几次
匹配值的下标有：[18]