二分查找法

一、二分查找（Binary Search）实现

限制：必须是对于有序数列，才能使用二分查找法
注意：mid = ( l + r ) / 2 可能会造成整型溢出，所以一般使用中间的索引mid = l + ( r - l ) / 2

1、递归实现二分查找

public class BinarySearch {
    private BinarySearch() {
    }

    ; //构造函数对外隐藏

    /**
     * 二分查找算法 递归实现
     *
     * @param data   传入一个E类型数组
     * @param target 用户要查找的目标值
     * @return 目标值的索引
     */
    public static <E extends Comparable<E>> int Search(E[] data, E target) {
        return Search(data, 0, data.length - 1, target);
    }

    /**
     * 一个私有的递归方法
     *
     * @param data
     * @param l      要处理数组的左边界
     * @param r      要处理数组的右边界
     * @param target
     * @param <E>
     * @return
     */
    private static <E extends Comparable<E>> int Search(E[] data, int l, int r, E target) {
        // 首先处理递归到底的情况 ,终止条件
        if (l > r) return -1; // 没有找到，返回-1
        int mid = l + (r - l) / 2;
        //如果mid和target相等 ，那么找到了
        if (data[mid].compareTo(target) == 0)
            return mid;
        // 如果中间值要小于 target 说明 target 在右区域
        if (data[mid].compareTo(target) < 0)
            return Search(data, mid + 1, r, target);
        //两种情况都判断了，那么直接返回 target 在左区域的情况
        return Search(data, l, mid - 1, target);
    }
}

2、非递归实现二分查找

public class BinarySearch {
    private BinarySearch() {
    }

    /**
     * @param data
     * @param target
     * @param <E>
     * @return
     */
    public static <E extends Comparable<E>> int Search(E[] data, E target) {
        int l = 0, r = data.length - 1;
        //循环查找
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if (data[mid].compareTo(target) == 0)
                return mid;
            if (data[mid].compareTo(target) < 0)
                //更新左边界
                l = mid + 1;
            else
                r = mid - 1;
        }
        //如果循环跳出没有找到，那么返回 -1 
        return -1;
    }
}

二、时间复杂度

排序是二分搜索法的前置条件。
o(logn) 级别的时间复杂度，但是并没有把排序的时间算进去。如果考虑到排序时间，使用最好的排序算法 o(logn) 。

三、二分查找法相关试题

1. leetcode 704 二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

提示：
你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。

解答：

class Solution {
    public int search(int[] nums, int target) {
        return search(nums,0,nums.length-1,target);
    }
    public int search(int[] nums,int l,int r,int target){
        if (l>r) return -1;
        int mid = l +(r-l)/2;
        if (nums[mid]==target){
            return mid;
        }
        else if (nums[mid]<target){
            return search(nums,mid+1,r,target);
        }
        else{
            return search(nums,l,mid-1,target);
        }
    }
}

2. leetcode 35 搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:

输入: [1,3,5,6], 5
输出: 2
示例 2:

输入: [1,3,5,6], 2
输出: 1
示例 3:

输入: [1,3,5,6], 7
输出: 4
示例 4:

输入: [1,3,5,6], 0
输出: 0

解答：

class Solution {
    public int searchInsert(int[] nums, int target) {
    	//数组为空 或者 数组长度为0时候的判断
        if (nums == null || nums.length == 0)
            return 0;
        int l = 0, r = nums.length - 1;
        // 查找数组中是否包含target 元素，返回其索引 ，注意 while 循环的判断条件是 l < r  
        while (l < r) {
            int mid = l + (r - l) / 2;
            if (nums[mid] == target) return mid;
            if (nums[mid] < target)
                l = mid + 1;
            else
                r = mid;
        }
		// 当 target 大于 nums[l] 的时候 ，此时要插入到最后一个位置，单独拿出来讨论。
        if(nums[l]<target)
            return l+1;
        else
            return l;
    }
}

3. leetcode 162 寻找峰值

峰值元素是指其值大于左右相邻值的元素。
给你一个输入数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。
你可以假设 nums[-1] = nums[n] = -∞ 。
示例 1：

输入：nums = [1,2,3,1]
输出：2
解释：3 是峰值元素，你的函数应该返回其索引 2。
示例 2：

输入：nums = [1,2,1,3,5,6,4]
输出：1 或 5
解释：你的函数可以返回索引 1，其峰值元素为 2；
或者返回索引 5， 其峰值元素为 6。
提示：
1 <= nums.length <= 1000
-231 <= nums[i] <= 231 - 1
对于所有有效的 i 都有 nums[i] != nums[i + 1]

解答：

//二分查找方式
class Solution {
    public int findPeakElement(int[] nums) {
        if (nums == null || nums.length == 0)
            return -1;
        int l = 0, r = nums.length - 1;
        while (l < r) {
            int mid = l + (r - l) / 2;
            if (nums[mid] > nums[mid + 1])
                r = mid;
            else
                l = mid + 1;
        }
        return l;
    }
}

//非二分查找方式
class Solution {
    //不用二分查找的方式
    public int findPeakElement(int[] nums) {
        if (nums.length == 1 || nums[0] > nums[1])
            return 0;
        for (int i = 1; i < nums.length - 1; i++) {
            if (nums[i] > nums[i - 1] && nums[i] > nums[i + 1])
                return i;
        }
        return nums.length - 1;
    }
}

4. leetcode 74 搜索二维矩阵

编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：
每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。

示例 1：

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
输出：true
示例 2：

输入：matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 13
输出：false

提示：
m == matrix.length
n == matrix[i].length
1 <= m, n <= 100
-104 <= matrix[i][j], target <= 104

解答：

//直接遍历，暴力求解
    public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0)
        	return false;
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                if (matrix[i][j]==target)
                    return true;
            }
        }
        return false;
    }

//其实这几个矩阵 从左到右 从上到下 就是一个有序的数组，思路就是将矩阵转换为数组（重点是如何将二维数组索引 转换成一维索引？），转换为二分查找的问题；
class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0)
            return false;
        //得到二维数组的行和列
        int row = matrix.length, col = matrix[0].length;
        //写出左右边界
        int l = 0, r = row * col - 1;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            //得到mid索引对应的值
            int element = matrix[mid / col][mid % col];
            if (element == target)
                return true;
            else if (element > target)
                r = mid - 1;
            else
                l = mid + 1;
        }
        return false;
    }
}

四、相关二分查找

1.给定一个有序数组和一个target 找到target的第一次出现的位置？（假定target存在在数组中）

public int search(int[] nums, int target) {
    if (nums.length == 0) return -1;
    int l = 0, r = nums.length - 1;
    while (l < r) {
        int mid = l + (r - l) / 2;
        if (nums[mid] < target) l = mid + 1;
        else r = mid;
    }
    return l;
}

2.给定一个有序数组和一个target 找到target的最后一次出现的位置？（假定target存在在数组中）

public int search(int[] nums, int target) {
    if (nums.length == 0) return -1;
    int l = 0, r = nums.length - 1;
    while (l < r) {
        int mid = l + (r - l + 1) / 2;
        if (nums[mid] > target) r = mid - 1;
        else l = mid;
    }
    return r;
}

3.给定一个有序数组和一个target ，找到target应该插入的索引位置是？（假定target不存在数组中）

public int search(int[] nums, int target) {
    if (nums.length == 0) return -1;
    int l = 0, r = nums.length - 1;
    while(l <= r) {
        int m = (l + r) / 2;
        if(nums[m] <= target) l = m + 1;
        else r = m - 1;
    }
    return l;
}

总结

以上两个可以解决的问题有？
1 、 解决一个有序数组中，某个target出现的 索引位置 【start , end 】;
2 、 解决一个有序数组中， 某个target出现的次数。

五、推广

云数据库RDS MySQL 版是全球最受欢迎的开源数据库之一，作为开源软件组合 LAMP（Linux + Apache + MySQL + Perl/PHP/Python） 中的重要一环，广泛应用于各类应用场景。
点击查看->>> 云数据库新年钜惠，新用户1折起，爆款5-8折，MySQL 1年仅需19.9元.