Binary Search 总结

Find First and Last Position of Element in Sorted Array ( Binary search标准模板走起；)

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] res = new int[]{-1, -1};
        if(nums == null || nums.length == 0) {
            return res;
        }
        res[0] = findFirstPosition(nums, target);
        res[1] = findLastPosition(nums, target);
        return res;
    }
    
    private int findFirstPosition(int[] nums, int target) {
        int start = 0; int end = nums.length - 1;
        while(start + 1 < end) {
            int mid = start + (end - start) / 2;
            if(nums[mid] == target) {
                end = mid;
            } else if(nums[mid] > target) {
                end = mid;
            } else {
                // nums[mid] < target;
                start = mid;
            }
        }
        
        if(nums[start] == target) {
            return start;
        }
        if(nums[end] == target) {
            return end;
        }
        return -1;
    }
    
    private int findLastPosition(int[] nums, int target) {
        int start = 0; int end = nums.length - 1;
        while(start + 1 < end) {
            int mid = start + (end - start) / 2;
            if(nums[mid] == target) {
                start = mid;
            } else if(nums[mid] > target) {
                end = mid;
            } else {
                // nums[mid] < target;
                start = mid;
            }
        }
        if(nums[end] == target) {
            return end;
        }
        if(nums[start] == target) {
            return start;
        }
        return -1;
    }
}

Search in Rotated Sorted Array (按照九章的模板来写；总体思想就是：确定哪段是升序的，然后把target钳住里面，判断是否在里面，否则搜另外一边；因为array是rotated，所以，只能是两边要么一边升序，把target放在升序的序列里面进行判断，如果不在，选另外一边)

Search In Rotated Sorted Array II (跟上面一题，不同的是，nums[mid] == nums[start] start++, 去掉一个相同的元素，搜索范围继续缩小就可以了。)

Search a 2D Matrix (Binary Search, 用[index / m][index % m] 来搜)

Search a 2D Matrix II (Binary search, 从左下角或者右上角开始找，如果 target > matrix[x][y], x++,否则y--;)

Missing Element in Sorted Array (这题很牛逼，把missing number的个数，用来做binary search的标准。 missing number 的个数是: nums[end] - nums[start] - (end - start); 4, (5,6) , 7 -- > 7 - 4  - (1 - 0) = 3 - 1 = 2; 注意：If k > missing, the result will be larger than the rightmost one in the array, we return nums[right] + k - missing.

Find K Closest Elements 先用binary search找到起始start point，然后用打擂台的方法O(K)的去取得最近的值；注意：findclosest的时候，如果相等的话，取前面的start；

Median of Two Sorted Array Find Kth, 每次跟A和B中的 第 k/2值进行比较；然后扔掉最小的那一部分，因为是保证没有用的，这样总体思路是缩小搜索范围；

Sqrt(x) 

public class Solution {
    /**
     * @param x: An integer
     * @return: The sqrt of x
     */
    public int sqrt(int x) {
        if(x < 0) {
            return -1;
        }
        if(x == 0) {
            return 0;
        }
        
        long start = 1; long end = x; // long防止溢出；
        while(start + 1 < end) {
            long mid = start + (end - start) / 2;
            if(mid * mid > x) {
                end = mid;
            } else {
                start = mid;
            }
        }
        
        if(end * end > x) {
            return (int)start;
        } else {
            return (int)end;
        }
    }
}

Sqrt(x) II 注意，0.1 的sqrt是0.316，所以超出了end，那么end就要取至少1开始的；end = Math.max(1, x);

public class Solution {
    /**
     * @param x: a double
     * @return: the square root of x
     */
    public double sqrt(double x) {
        if(x < 0) {
            return -1;
        }
        
        if(x == 0) {
            return 0;
        }
        
        double start = 0; 
        // 数字属于（0，1）返回，上界需要取1，比如0.1 sqrt是0.3，超过了0.1；上界要超过x；
        double end = Math.max(x, 1.0);
        double eps = 1e-10;
        while(start + eps < end) {
            double mid = start + (end - start) / 2;
            
            if(mid*mid > x) {
                end = mid;
            } else {
                start = mid;
            }
        }
        
        if(end*end > x) {
            return start;
        }
        return end;
    }
}