LeetCode - Binary Search 总结

模版

(l + 1 < r) {
  int mid = l + (r - l) / 2;
  if (num[mid] < target) {
     start = mid;
  } else {
     end = mid;
  }
  if (num[start] == target) return start;
  if (num[end] == target) return end;
  return -1;
}

(l <= r) {
  int mid = l + (r - 1) / 2;
  if (num[mid]) < target) {
     start = mid + 1;
  } else if (nums[mid] > target) {
     end = mid - 1;
  } else {
     return mid;
  }
  return -1;
}

(l < r) {
  int mid = l + (r - 1) / 2;
  if (num[mid]) < target) {
     start = mid + 1;
  } else if (nums[mid] > target) {
     end = mid;
  } else {
     return mid;
  }
  return -1;
}

33. Search in Rotated Sorted Array

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        if len(nums)==0: return -1
        l=0
        r = len(nums)-1
        while l+1<r:
            mid = l+int((r-l)/2)
            if nums[mid]>=nums[l]:
                if nums[l]<=target and target<nums[mid]:
                    r=mid
                else: l=mid
            else:
                if nums[mid]<target and target<=nums[r]:
                    l=mid
                else: r=mid
        if nums[l]==target: return l
        if nums[r]==target: return r
        return -1

34. Find First and Last Position of Element in Sorted Array

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        if len(nums)==0: return [-1, -1]
        res = []
        l = 0
        r = len(nums) - 1
        while l+1<r:
            mid = l+int((r-l)/2)
            if target <= nums[mid]: r=mid
            else: l=mid
        if nums[l]==target: res.append(l)
        elif nums[r]==target: res.append(r)
        else: return [-1, -1]
        
        l = 0
        r = len(nums) - 1
        while l+1<r:
            mid = l+int((r-l)/2)
            if target >= nums[mid]: l=mid
            else: r=mid
        if nums[r]==target: res.append(r)
        elif nums[l]==target: res.append(l)
        return res

287. Find the Duplicate Number

Think as a linked list [Cycle Detection in Linked List]

1.Hashing: iterate and count the number of occurance (extra space)

2.Floyed's Cycle Detection Algorithm / tortoise and hare algorithm
Prove: 1) part 1: fast 2, slow 1 -> if have a cycle, must meet
            2) part 2: fast 1, slow 1
                -> must meet
                -> meet at the entry point

Binary Search

class Solution:
    def findDuplicate(self, nums: List[int]) -> int:
        l=1
        r=len(nums)
        while l<r:
            mid =l+int((r-l)/2)
            cnt = sum(x<=mid for x in nums)
            if cnt<=mid:
                l=mid+1
            else:
                r=mid
        return r
        

class Solution:
    def findDuplicate(self, nums: List[int]) -> int:
        l=1
        r=len(nums)-1
        while l<=r:
            mid =l+int((r-l)/2)
            cnt = sum(x<=mid for x in nums)
            if cnt>mid:
                r=mid-1
            else:
                l=mid+1
        return l
        

278. First Bad Version

class Solution:
    def firstBadVersion(self, n):
        l=1
        r=n
        while l+1<r:
            mid = l+int((r-l)/2)
            if isBadVersion(mid):
                r=mid
            else:
                l=mid
        if isBadVersion(l):
            return l
        elif isBadVersion(r):
            return r
        return -1
        

class Solution:
    def firstBadVersion(self, n):
        l=1
        r=n
        while l<=r:
            mid = l+int((r-l)/2)
            if isBadVersion(mid):
                r=mid-1
            else:
                l=mid+1
        return l
        

class Solution:
    def firstBadVersion(self, n):
        l=1
        r=n+1
        while l<r:
            mid = l+int((r-l)/2)
            if isBadVersion(mid):
                r=mid
            else:
                l=mid+1
        return r
        

153. Find Minimum in Rotated Sorted Array

class Solution:
    def findMin(self, nums: List[int]) -> int:
        if nums[0]<=nums[len(nums)-1]: return nums[0]
        l=0
        r=len(nums)-1
        while l+1<r:
            mid = l+int((r-l)/2)
            if nums[l]<nums[mid]:
                l=mid
            else:
                r=mid
        return min(nums[l], nums[r])
        

class Solution:
    def findMin(self, nums: List[int]) -> int:
        if nums[0]<=nums[len(nums)-1]: return nums[0]
        l=0
        r=len(nums)-1
        while l<r:
            mid = l+int((r-l)/2)
            if nums[mid]>=nums[r]:
                l=mid+1
            else:
                r=mid
        return nums[l]