二分法查找的实现与总结(Java)

二分法查找

基本介绍

算法：二分法查找适用于数据量较大时，但是数据需要先排好顺序。

主要思想是：（设查找的数组区间为array[low, high]）

• 确定该区间的中间位置K
• 将查找的值T与array[k]比较。若相等，查找成功返回此位置；否则确定新的查找区域，继续二分查找。区域确定如下：a.array[k]>T 由数组的有序性可知array[k,k+1,……,high]>T;故新的区间为array[low,……，K-1]b.array[k]<T 类似上面查找区间为array[k+1,……，high]。

时间复杂度为: O(log₂n)。

代码实现

非递归查找单个值

/**
     * 非递归的二分法查找
     *
     * @param arr    待查找的数组，此处数组默认按照从小到大排列
     * @param target 待查找的值
     * @return 返回待查找值的下标，若未找到返回-1
     */
    public static int binarySearchNoRecursion(int[] arr, int target) {
        int left = 0;//左角标
        int right = arr.length - 1;//右角标
        int mid;//中间值
        while (left <= right) {
            mid = (left + right) / 2;
            if (target < arr[mid]) {
                right = mid - 1;
            } else if (target > arr[mid]) {
                left = mid + 1;
            } else {
                return mid;
            }
        }
        return -1;
    }

非递归查找所有符合条件的值

/**
     * @param arr    待查找的数组，此处数组默认按照从小到大排列
     * @param target 待查找的值
     * @return 返回待查找值的集合，若未找到返回null
     */
    public static List<Integer> binarySearchAllNoRecursion(int[] arr, int target) {
        int left = 0;//左角标
        int right = arr.length - 1;//右角标
        int mid;
        while (left <= right) {
            mid = (left + right) / 2;
            if (target < arr[mid]) {
                right = mid - 1;
            } else if (target > arr[mid]) {
                left = mid + 1;
            } else {
                List<Integer> list = new ArrayList<>();
                list.add(mid);
                int temp;//使用临时变量记录当前坐标
                //向左查找
                temp = mid - 1;
                while (temp >= 0 && arr[temp] == target) {
                    list.add(temp--);
                }
                //向右查找
                temp = mid + 1;
                while (temp < arr.length && arr[temp] == target) {
                    list.add(temp++);
                }
                return list;
            }
        }
        return null;
    }

递归查找单个值

/**
     * 递归的二分法查找
     *
     * @param arr    待查找的数组，此处数组默认按照从小到大排列
     * @param left   左角标
     * @param right  右角标
     * @param target 待查找的值
     * @return 返回待查找值的下标，若未找到返回-1
     */
    public static int binarySearchByRecursion(int[] arr, int left, int right, int target) {
        if (left > right) {
            return -1;
        }
        int mid = (left + right) / 2;
        if (target < arr[mid]) {
            return binarySearchByRecursion(arr, left, mid - 1, target);
        } else if (target > arr[mid]) {
            return binarySearchByRecursion(arr, mid + 1, right, target);
        } else {
            return mid;
        }
    }

递归查找所有符合条件的值

/**
     * @param arr    待查找的数组，此处数组默认按照从小到大排列
     * @param left   左角标
     * @param right  右角标
     * @param target 待查找的值
     * @return 返回待查找值的集合，若未找到返回null
     */
    public static List<Integer> binarySearchAllByRecursion(int[] arr, int left, int right, int target) {
        if (left > right) {
            return null;
        }
        int mid = (left + right) / 2;
        if (target < arr[mid]) {
            return binarySearchAllByRecursion(arr, left, mid - 1, target);
        } else if (target > arr[mid]) {
            return binarySearchAllByRecursion(arr, mid + 1, right, target);
        } else {
            List<Integer> list = new ArrayList<>();
            list.add(mid);
            int temp;//临界变量记录mid值
            //向左判断
            temp = mid - 1;
            while (temp >= 0 && target == arr[temp]) {
                list.add(temp--);
            }
            //向右判断
            temp = mid + 1;
            while (temp < arr.length && target == arr[temp]) {
                list.add(temp++);
            }
            return list;
        }
    }

代码汇总

package com.athome.binarysearch;

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

/**
 * Description:
 * Author:江洋大盗
 * Date:2021/1/17 9:11
 */
public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {1, 5, 6, 9, 9, 9, 9, 10, 24, 39, 42};
        System.out.println("非递归查找10:" + binarySearchNoRecursion(arr, 10));
        List<Integer> list = binarySearchAllNoRecursion(arr, 9);
        System.out.println("非递归查找所有9:" + list);
        System.out.println("递归查找10:" + binarySearchByRecursion(arr, 0, arr.length - 1, 10));
        List<Integer> list1 = binarySearchAllByRecursion(arr, 0, arr.length - 1, 9);
        System.out.println("递归查找所有9:" + list1);


    }

    /**
     * 非递归的二分法查找
     *
     * @param arr    待查找的数组，此处数组默认按照从小到大排列
     * @param target 待查找的值
     * @return 返回待查找值的下标，若未找到返回-1
     */
    public static int binarySearchNoRecursion(int[] arr, int target) {
        int left = 0;//左角标
        int right = arr.length - 1;//右角标
        int mid;//中间值
        while (left <= right) {
            mid = (left + right) / 2;
            if (target < arr[mid]) {
                right = mid - 1;
            } else if (target > arr[mid]) {
                left = mid + 1;
            } else {
                return mid;
            }
        }
        return -1;
    }

    /**
     * @param arr    待查找的数组，此处数组默认按照从小到大排列
     * @param target 待查找的值
     * @return 返回待查找值的集合，若未找到返回null
     */
    public static List<Integer> binarySearchAllNoRecursion(int[] arr, int target) {
        int left = 0;//左角标
        int right = arr.length - 1;//右角标
        int mid;
        while (left <= right) {
            mid = (left + right) / 2;
            if (target < arr[mid]) {
                right = mid - 1;
            } else if (target > arr[mid]) {
                left = mid + 1;
            } else {
                List<Integer> list = new ArrayList<>();
                list.add(mid);
                int temp;//使用临时变量记录当前坐标
                //向左查找
                temp = mid - 1;
                while (temp >= 0 && arr[temp] == target) {
                    list.add(temp--);
                }
                //向右查找
                temp = mid + 1;
                while (temp < arr.length && arr[temp] == target) {
                    list.add(temp++);
                }
                return list;
            }
        }
        return null;
    }

    /**
     * 递归的二分法查找
     *
     * @param arr    待查找的数组，此处数组默认按照从小到大排列
     * @param left   左角标
     * @param right  右角标
     * @param target 待查找的值
     * @return 返回待查找值的下标，若未找到返回-1
     */
    public static int binarySearchByRecursion(int[] arr, int left, int right, int target) {
        if (left > right) {
            return -1;
        }
        int mid = (left + right) / 2;
        if (target < arr[mid]) {
            return binarySearchByRecursion(arr, left, mid - 1, target);
        } else if (target > arr[mid]) {
            return binarySearchByRecursion(arr, mid + 1, right, target);
        } else {
            return mid;
        }
    }

    /**
     * @param arr    待查找的数组，此处数组默认按照从小到大排列
     * @param left   左角标
     * @param right  右角标
     * @param target 待查找的值
     * @return 返回待查找值的集合，若未找到返回null
     */
    public static List<Integer> binarySearchAllByRecursion(int[] arr, int left, int right, int target) {
        if (left > right) {
            return null;
        }
        int mid = (left + right) / 2;
        if (target < arr[mid]) {
            return binarySearchAllByRecursion(arr, left, mid - 1, target);
        } else if (target > arr[mid]) {
            return binarySearchAllByRecursion(arr, mid + 1, right, target);
        } else {
            List<Integer> list = new ArrayList<>();
            list.add(mid);
            int temp;//临界变量记录mid值
            //向左判断
            temp = mid - 1;
            while (temp >= 0 && target == arr[temp]) {
                list.add(temp--);
            }
            //向右判断
            temp = mid + 1;
            while (temp < arr.length && target == arr[temp]) {
                list.add(temp++);
            }
            return list;
        }
    }
}

测试结果：

---

结语

只要能收获甜蜜，荆棘丛中也有蜜蜂忙碌的身影，未来的你一定会感谢现在努力的自己。