[LC] Binary Search 题目/方法总结

Binary search 是最简单也十分常用的一种算法，能把O(n) 的搜索降到O(logn)这个帖子的总结是参考大神Grandyang的，甚至很多地方是直接抄袭过来，原贴在这里http://www.cnblogs.com/grandyang/p/6854825.html

Binary Search Template

二分法常见关键词：sorted；

二分常见痛点有以下几个：

• 循环条件：start + 1 < end
• mid = start + (end - start) /2;
• A[mid] ==, < > 
• return A[start] or A[end] 

第一境界：寻找target

这个level其实就是直接套用模板，一般就是在sorted array里面找target/insertion；

例题： https://leetcode.com/problems/binary-search/description/

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

例题：https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/description/

这个题目非常直接，直接考察找两个postion，也是十分简单，就是套用模板；可以采取套用模板两次，找到first，last；也可以先找到first，然后把指针往后移找到last；

也可以先o(logn)找到first，然后在first，end直接二分o(logm)找到last；这里选用了第二种方法，o(logn) 找到first，然后平移pointer去找last，worst case O(n);

    public int[] searchRange(int[] A, int target) {
        if (A.length == 0) return new int[]{-1, -1};
        
        int s = 0, e = A.length - 1;
        while (s + 1 < e){
            int mid = s + (e - s)/ 2;
            if (A[mid] >= target){
                e = mid;
            }else{
                s = mid + 1;
            }
        }
        
        int first = -1;
        if (A[s] == target){
            first = s;
        }else if (A[e] == target){
            first = e;
        }else{
            return new int[]{-1, -1};
        }
        
        int last = first;
        while (last + 1 < A.length && A[last + 1] == target){
            last ++;
        }
        
        return new int[]{first, last};
    } 

第二境界：寻找OOXX，即满足条件的最后/第一 OOOOOOO...OOXX….XXXXXX

这个level 大部分是找满足条件的一个或者最后一个，即分界处，相关常见关键词：first、last、rotated sorted、peak etc

例题：https://leetcode.com/problems/first-bad-version/description/

太简单就不贴代码了；

Search in rotated sorted array

例题：https://leetcode.com/problems/search-in-rotated-sorted-array/description/

这个题目就是画图，找到几种情况start, end该怎么变就行，主要关注的是A[end] and A[mid] 的关系。

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

例题：https://leetcode.com/problems/search-in-rotated-sorted-array-ii/description/

是上面那题的变形，要注意的是有duplicate的出现，那么我们A[start] == A[end]成为可能，这样我们变换end的时候，只能让end --， 不能直接end = mid;

 

    public boolean search(int[] A, int target) {
        if (A.length == 0) return false; 
        
        int start = 0, end = A.length - 1, mid;

        while (start + 1 < end){
            mid = start + (end - start) / 2;
            System.out.println("mid=" + mid);
            if (A[mid] == target) return true;
            if (A[mid] > target){
                if (target <= A[end] && A[mid] > A[end]){
                    start = mid;
                }else{
                    end = (A[mid] < A[end]) ? mid : end - 1;
                }
            }else{ // A[mid] < target
                if (target > A[end] && A[mid] <= A[end]){
                    end = (A[mid] < A[end]) ? mid : end - 1;
                }else{
                    start = mid;
                }
            }
        }
        
        if (A[start] == target || A[end] == target) return true;
        return false;
    }

例题：https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/

这可以转化成找第一个数where A[i] < A[i + 1];，我们可以令target = A[end];这样转化成找到first value that less than target;

    public int findMin(int[] A) {
        // change to find the first value that less than the A[end];
        int s = 0, e = A.length - 1, target = A[e];
        while (s + 1 < e){
            int mid = s + (e - s) / 2;
            if (A[mid] >= target){
                s = mid;
            }else{
                e = mid;
            }
        }
        
        return A[s] <= target ? A[s] : A[e];
        
    }

https://leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/description/

上一题的拓展，主要不同就是有duplicate；和search in rotated array 一样，有duplicate的时候我们不能简单end = mid或者start = mid，而是s++ 或者e++，想象一下这个case[3,1,3,3,3], 如果我们看到A[mid] >= target(3); 就赋值-> start = mid，这样会丢失掉1这个值，所以我们要的是start ++；

    public int findMin(int[] A) {
        // change to find the first value that less than the A[end];
        int s = 0, e = A.length - 1, target = A[e];
        while (s + 1 < e){
            int mid = s + (e - s) / 2;
            if (A[mid] >= target){
                s ++;
            }else{
                e = mid;
            }
        }
        
        return A[s] <= target ? A[s] : A[e];
        
    }

自己找higher bound

例题：https://leetcode.com/problems/search-in-a-sorted-array-of-unknown-size/description/

size 不知道，也即是没有end，那我们就用一个e做expoenital increase直到找到array中大于target，就可以赋值为这个higher bound；

 1     public int search(ArrayReader reader, int target) {
 2         int e = 1;
 3         while (reader.get(e) < target){
 4             e <<= 1;
 5         }
 6         
 7         int s = e >> 1;
 8         while (s + 1 < e){
 9             int mid = s + (e - s) / 2;
10             if (reader.get(mid) == target){
11                 return mid;
12             }else if (reader.get(mid) < target){
13                 s = mid + 1;
14             }else{
15                 e = mid - 1;
16             }
17         }
18         
19         if (reader.get(s) == target){
20             return s;
21         }else if (reader.get(e) == target){
22             return e;
23         }
24         
25         return -1;
26     }

 

 应用实例

例题：https://leetcode.com/problems/heaters/description/

这个题目可以对每个房子找到它在heater中的位置，然后求两个最小值，然后对所有房子这个最小值求最大值即可；

其实这个题不需要用binary search；用two-pointer其实更好

class Solution {
    public int findRadius(int[] houses, int[] heaters) {
        int max = 0;
        Arrays.sort(heaters);
        
        // for each house, find its position in heater;
        for (int h : houses){
            //int min = find(heaters, h);
            //System.out.println("h=" + h + " min=" + min);
            max = Math.max(max, find(heaters, h));
        }
        
        return max;
    }
    
    private int find(int[] A, int h){
        int s = 0, e = A.length - 1;
        while (s + 1 < e){
            int mid = s + (e - s) / 2;
            if (A[mid] == h){
                return 0;
            }else if (A[mid] < h){
                s = mid;
            }else{
                e = mid;
            }
        }
        
        return Math.min(Math.abs(h - A[s]), Math.abs(A[e] - h));
    }
}

 two pointer:

class Solution {
    public int findRadius(int[] houses, int[] heaters) {
        Arrays.sort(houses);
        Arrays.sort(heaters);
        
        int j = 0, max = 0;
        for (int i = 0; i < houses.length; i ++){
            // when the next heaters is closer to the current house, we move pointer to next heater
            while (j + 1 < heaters.length && 
                   Math.abs(heaters[j] - houses[i]) >= Math.abs(heaters[j+1] - houses[i])){
                j ++;
            }
            
            max = Math.max(max, Math.abs(heaters[j] - houses[i]));
        }
        
        return max;
    }
}

 例题： https://leetcode.com/problems/arranging-coins/description/

这是一个典型的二分数学问题，利用sum = (1 + end) * end / 2 和 n的关系我们可以看出是找最后一个满足条件的位置，二分典型oooxxx问题；

    public int arrangeCoins(int n) {
        long s = 0, e = n;
        long nlong = (long) n;
        
        while (s + 1 < e){
            long mid = s + (e - s) / 2;
            
            // expected sum = (1 + mid) * mid / 2;
            if ( (1 + mid) * mid  / 2 <= nlong){
                s = mid;
            }else{
                e = mid - 1;
            }
        }
        
        if ((1 + e) * e / 2 <= nlong) return (int) e;
        if ((1 + s) * s / 2 <= nlong) return (int) s;
        return 0;
    }

相似例题： 

https://leetcode.com/problems/valid-perfect-square/description/

https://leetcode.com/problems/valid-triangle-number/description/ 

https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/description/

第三境界：去掉一半

这一类博主还没有掌握也是最头疼的一类，只能通过多做题目来积累经验了；