算法基础之二分查找

二分查找

---

源代码链接： https://github.com/lankuohsing/LeetCode-Java/tree/master/LeetCodeInJava/src/binary_search

1.二分查找的一般场景(查找升序数组target值区域的左边界)

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target，返回target在nums中的下标；如果目标值不存在，则返回-1；如果目标值存在多个，则返回最左边那个。
核心代码：

public int findLeftIndex(int nums[], int target) {
        // 循环继续的条件：start <= end
        // 更新start的条件：nums[middle] < target
        // 如果target不存在，最终start为第一个大于target的下标（如果没有大于target的，就等于nums.length）
        // 如果target存在，最终start为最左边那个下标
        if (nums.length == 0) {
            return -1;
        }
        int start = 0;
        int end = nums.length - 1, middle;
        while (start <= end) {
            middle = start + (end - start) / 2;//防止溢出
            if (nums[middle] < target) {
                start = middle + 1;
            } else {
                end = middle - 1;
            }
        }
        int left = start;
        System.out.println("原始的left:" + left);
        if (left == nums.length || nums[left] != target) {
            left = -1;
        }
        return left;
    }

解释：
· 两个哨兵（start和end）分别从数组最左端和最右端开始往中间逼进，每次逼近都是用middle+1更新start或者用middle-1更新start，其中middle = (start + end) / 2（这也就是二分查找的来历，也叫对半查找）。
· 循环继续的条件为start≤end。
· 更新start的条件为nums[middle] < target，更新end的条件为前面条件的else情况（所以如果存在一个或多个target，都会更新middle）
· 当循环跳出时，一定有start>end。为什么不在nums[middle]==target的时候退出循环？因为如果有多个target的话，nums[middle]==target无法保证是最左边那个target。

当退出循环后，一定有start==end+1.此时的nums[start]有两种情况：

1. nums[start]==target，且nums[start]是最左边的那个target
2. start == nums.length（越界了），此时说明数组里面所有元素都小于target
3. nums[start] != target，说明target不存在（但是target的值确实在数组区间内）

因此上面的代码在返回前有如下代码来决定返回值（返回值记为left）：

int left = start;
System.out.println("原始的left:" + left);
if (left == nums.length || nums[left] != target) {
    left = -1;
}
return left;

完整代码见package：find_left_right_index

2.二分查找的简单场景-升序不重复数组查找指定元素

leetcode 704. 二分查找
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。假设 nums 中的所有元素是不重复的。

因为数组元素不重复，因此可以提前剪枝（nums[middle]==target时直接返回）。同时，可以省去循环后面后续判断，因为如果是等到循环正常结束的话一定是元素不存在，因此可以直接在循环结束后返回-1.

public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int result = -1;
        while (left <= right) {// 注意是小于等于
            int middle = left + (right - left) / 2;
            if (nums[middle] == target) {
                result = middle;
                break;
            } else {
                if (target < nums[middle]) {
                    right = middle - 1;// 注意要减1
                } else {
                    left = middle + 1;// 注意要加1
                }
            }
        }
        return result;
    }

3.二分查找思想的高阶应用（持续更新中）

3.1. 二分查找的一般场景(查找升序数组target值区域的右边界)

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target，返回target在nums中的下标；如果目标值不存在，则返回-1；如果目标值存在多个，则返回最右边那个。

public int findRightIndex(int nums[], int target) {
        // 循环继续的条件：start <= end
        // 更新start的条件：nums[middle] <= target
        // 如果target不存在，最终start为第一个大于target的下标（如果没有大于target的，就等于nums.length）
        // 如果target存在，最终start为最右边那个下标+1
        if (nums.length == 0) {
            return -1;
        }
        int start = 0;
        int end = nums.length - 1, middle;
        while (start <= end) {
            middle = start + (end - start) / 2;
            if (nums[middle] <= target) {
                start = middle + 1;
            } else {
                end = middle - 1;
            }
        }
        int right = start;
        System.out.println("原始的right:" + right);
        if (right == nums.length) {
            if (nums[right - 1] != target) {
                right = -1;
            }
        } else {
            if (right - 1 < 0 || nums[right - 1] != target) {
                right = -1;
            }
        }

        return right == -1 ? right : right - 1;
    }

3.2. 升序数组中统计目标值出现的次数

剑指 Offer 53 - I. 在排序数组中查找数字 I
统计一个数字在排序数组中出现的次数。注意，虽然这里说的是排序数组，但是测试数据都是升序数组，所以我们的代码也按照升序数组来处理。严格意义上，应该先判断是否为升序还是降序，然后做一些微小的改变

class Solution {
    public int search(int[] nums, int target) {
        int left = findLeftIndex(nums,target);
        int right = findRightIndex(nums,target);
        if(left==-1||right==-1){
            return 0;
        } else{
            return right-left+1;
        }
    }
    public int findLeftIndex(int nums[], int target) {
        // 循环继续的条件：start <= end
        // 更新start的条件：nums[middle] < target
        // 如果target不存在，最终start为第一个大于target的下标（如果没有大于target的，就等于nums.length）
        // 如果target存在，最终start为最左边那个下标
        if (nums.length == 0) {
            return -1;
        }
        int start = 0;
        int end = nums.length - 1, middle;
        while (start <= end) {
            middle = (start + end) / 2;
            if (nums[middle] < target) {
                start = middle + 1;
            } else {
                end = middle - 1;
            }
        }
        int left = start;
        if (left == nums.length || nums[left] != target) {
            left = -1;
        }
        return left;
    }

    public int findRightIndex(int nums[], int target) {
        // 循环继续的条件：start <= end
        // 更新start的条件：nums[middle] <= target
        // 如果target不存在，最终start为第一个大于target的下标（如果没有大于target的，就等于nums.length）
        // 如果target存在，最终start为最右边那个下标
        if (nums.length == 0) {
            return -1;
        }
        int start = 0;
        int end = nums.length - 1, middle;
        while (start <= end) {
            middle = (start + end) / 2;
            if (nums[middle] <= target) {
                start = middle + 1;
            } else {
                end = middle - 1;
            }
        }
        int right = start;
        if (right == nums.length) {
            if (nums[right - 1] != target) {
                right = -1;
            }
        } else {
            if (right - 1 < 0 || nums[right - 1] != target) {
                right = -1;
            }
        }
        return right == -1 ? right : right - 1;//
    }
}

3.3. 魔术索引（简单情形）

魔术索引。 在数组A[0…n-1]中，有所谓的魔术索引，满足条件A[i] = i。
给定一个有序整数数组，编写一种方法找出魔术索引，若有的话，在数组A中找出一个魔术索引，如果没有，则返回-1。
若有多个魔术索引，返回索引值最小的一个。
这里考虑简单情形，即数组中没有重复元素（严格单调递增数组）

public class Solution {
    public int findMagicIndex(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        while (left <= right) {
            int middle = left + (right - left) / 2;
            if (nums[middle] >= middle) {
                right = middle - 1;
            } else {
                left = middle + 1;
            }
        }
        if (left == nums.length || nums[left] != left) {
            left = -1;
        }
        return left;
    }
}

3.4. 魔术索引（复杂情形情形）

魔术索引。 在数组A[0…n-1]中，有所谓的魔术索引，满足条件A[i] = i。
给定一个有序整数数组，编写一种方法找出魔术索引，若有的话，在数组A中找出一个魔术索引，如果没有，则返回-1。
若有多个魔术索引，返回索引值最小的一个。
这里考虑复杂情形，即数组中可能有重复元素

public class Solution {
    public int findMagicIndex(int[] nums) {
        return getAnswer(nums, 0, nums.length - 1);
    }

    int getAnswer(int[] nums, int left, int right) {
        if (left > right) {
            return -1;
        }
        int middle = left + (right - left) / 2;
        int answer = getAnswer(nums, left, middle - 1);
        if (answer != -1) {
            return answer;
        } else {
            if (middle == nums[middle]) {
                return middle;
            }
        }
        return getAnswer(nums, middle + 1, right);
    }
}