二分法总结

Leetcode-704 二分查找
【给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。】

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

Leetcode-74 搜索二维矩阵
【编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：
每行中的整数从左到右按升序排列。每行的第一个整数大于前一行的最后一个整数】

class Solution(object):
    def searchMatrix(self, matrix, target):
        """
        :type matrix: List[List[int]]
        :type target: int
        :rtype: bool
        """

        m = len(matrix)
        n = len(matrix[0])

        i,j  = m-1,0

        while i>=0 and j<n:
            if matrix[i][j]<target:j+=1
            elif matrix[i][j]>target:i-=1
            else:return True
        return False

Leetcode-162 寻找峰值
【峰值元素是指其值严格大于左右相邻值的元素。给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。】

class Solution(object):
    def findPeakElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        left,right = 0, len(nums)-1
        

        while left<right:
            mid = left + (right-left)//2

            if nums[mid] < nums[mid+1]:
                left = mid + 1
            elif nums[mid] < nums[mid-1]:
                right = mid
            else:
                return mid
        return right
        

剑指 Offer 51. 数组中的逆序对
【在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。】

class Solution:
    def InversePairs(self , data: List[int]) -> int:
        # write code here
        def mergesort(l,r):
            if l>=r: return 0
            m = (l+r)//2
            res = mergesort(l,m) + mergesort(m+1,r)
            i = l
            j=m+1
            temp[l:r+1] = data[l:r+1]
            
            for k in range(l,r+1):
                if i == m+1:
                    
                    data[k]=temp[j]
                    j+=1
                elif j==r+1 or temp[i]<=temp[j]:
                    data[k]=temp[i]
                    i+=1
                else:
                    data[k] = temp[j]
                    j+=1
                    res += m-i+1
            return res
        temp = [0]*len(data)
        return (mergesort(0,len(data)-1))%1000000007

81. 搜索旋转排序数组 II
【已知存在一个按非降序排列的整数数组 nums ，数组中的值不必互不相同。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转 ，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,4,4,5,6,6,7] 在下标 5 处经旋转后可能变为 [4,5,6,6,7,0,1,2,4,4] 。

给你 旋转后 的数组 nums 和一个整数 target ，请你编写一个函数来判断给定的目标值是否存在于数组中。如果 nums 中存在这个目标值 target ，则返回 true ，否则返回 false 。
你必须尽可能减少整个操作步骤。】

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: bool
        """
        if not nums: return -1
        left, right = 0, len(nums) - 1
        while left <= right:
            mid = (left + right) / 2
            if nums[mid] == target:
                return True
            if nums[left] == nums[right]:
                left += 1
                continue
            if nums[mid] <= nums[right]:
                if target > nums[mid] and target <= nums[right]:
                    left = mid + 1
                else:
                    right = mid - 1
            else:
                if target < nums[mid] and target >= nums[left]:
                    right = mid - 1
                else:
                    left = mid + 1
        return False