二分查找

34. 在排序数组中查找元素的第一个和最后一个位置

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int left = findFirst(nums, target);
        int right = findLast(nums, target);
        return new int[]{left,right};
    }

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

    public int findLast(int[] nums, int target){
        int lo = 0;
        int hi = nums.length - 1;
        int index = -1;
        while (lo <= hi) {
            int mid = (hi - lo)/2 + lo;
            if (nums[mid] <= target) {
                lo = mid + 1;
            } else  {
                hi = mid - 1;
            }
            if (nums[mid] == target) {
                index = mid;
            }
        }
        return index;
    }
}

35. 搜索插入位置

class Solution {
    public int searchInsert(int[] nums, int target) {
        int low = 0;
        int hight = nums.length - 1;
        int ans = nums.length;

        while (low <= hight) {
            int mid = low + (hight - low) / 2;
            if (target <= nums[mid]) {
                ans = mid;
                hight = mid - 1;
            }
            else {
                low = mid + 1;
            }
        }
        return ans;
    }
}

74. 搜索二维矩阵

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int row = matrix.length, column = matrix[0].length;
        int r = 0, c = matrix[0].length - 1;
        if(matrix==null || row==0 || column==0) {
            return false;
        } 
        while(r < row && c >= 0) {
            if(matrix[r][c]==target) {
                return true;
            } else if(matrix[r][c] < target) {
                r++;
            } else {
                c--;
            }
        }
        return false;
    }
}

153. 寻找旋转排序数组中的最小值

class Solution {
    public int findMin(int[] nums) {
        int low = 0;
        int high = nums.length - 1;
        int mid = 0;
        while (low < high) {
            mid = (high - low) / 2 + low;
            if (nums[mid] >= nums[high]) {
                low = mid+1;
            } else {
                high = mid;
            }
        }
        return nums[low];
    }
}

154. 寻找旋转排序数组中的最小值 II

class Solution {
    public int findMin(int[] nums) {
        int low = 0;
        int high = nums.length - 1;
        int mid = 0;
        while(low < high) {
            mid = low + (high - low) / 2;
            if(nums[mid] > nums[high]) {
                low = mid + 1;
            } else if(nums[mid] < nums[high]) {
                high = mid;
            } else {
                high -= 1;
            }
        }
        return nums[low];
    }
}

167. 两数之和 II - 输入有序数组

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int n = numbers.length;
        for (int i = 0; i < n; i++) {
            int lo = i + 1, hi = n - 1;
            while (lo <= hi) {
                int mid = lo + (hi - lo) / 2;
                if (numbers[mid] == target - numbers[i]) {
                    return new int[]{i + 1, mid + 1};
                } else if (numbers[mid] < target - numbers[i]) {
                    lo = mid + 1;
                } else {
                    hi = mid - 1;
                }
            }
        }
        return new int[]{-1, -1};
    }
}