四种二分法的区别：

二分法有几种变形：

 

585  山脉序列中的最大值

first position of target
457 Classical Binary Search
458 Last Position of Target

 

他们的区别在于：

 

mountainSequence
二分也不能太死板呀，边界可以根据具体问题具体分析。
一定要给left = m1 + 1，要不然会超时
最后返回这个
            else:
                left = m1
                right = m2
            
        return max(nums[left], nums[right])


first position of target
只有两个if else，没有第三个if


457 Classical Binary Search
任意找一个
            else:
                return mid


458 Last Position of Target
            else:
                start = mid 

 

用图片展示区别

 

 

 

四种方法程序：

 

 二分查找 · first position of target
 

class Solution:
    # @param nums: The integer array
    # @param target: Target number to find
    # @return the first position of target in nums, position start from 0 
    def binarySearch(self, nums, target):
        # write your code here
        left, right = 0, len(nums)
        while left + 1 < right :
            mid = (left + right) // 2
            if nums[mid] < target :
                left = mid
            else :
                right = mid   #第一次，最后一次，随意三种二分查找都是在这里变化了


        if nums[left] == target :
            return left
        elif nums[right] == target :
            return right
        return -1;

 

 

其实，查找最左侧目标这样写更好理解

 

 二分查找 · first position of target

class Solution:
    # @param nums: The integer array
    # @param target: Target number to find
    # @return the first position of target in nums, position start from 0 
    def binarySearch(self, nums, target):
        # write your code here
        left, right = 0, len(nums)
        while left + 1 < right :
            mid = (left + right) // 2
            if nums[mid] < target :
                left = mid
            elif nums[mid] > target:
                right = mid 
            else :
                right = mid   #


        if nums[left] == target :
            return left
        elif nums[right] == target :
            return right
        return -1;

 

 

 

457 Classical Binary Search
 

#随便找一个就行
class Solution:
    """
    @param nums: An integer array sorted in ascending order
    @param target: An integer
    @return: An integer
    """
    def findPosition(self, nums, target):
        # write your code here
        if not nums or target is None:
            return -1
            
        start, end = 0, len(nums) - 1
        while start + 1 < end:
            mid = (end + start)//2
            if target < nums[mid]:
                end = mid
            elif target > nums[mid]:
                start = mid
            else:
                return mid
        
        if target == nums[start]:
            return start
        if target == nums[end]:
            return end 
        return -1
    



                    
my_solution = Solution()
A = [1, 2, 2, 4, 5, 5]
target = 2
result = my_solution.findPosition(A, target)
print('result is',result)     

 

 

458 Last Position of Target
 

class Solution:
    # @param {int[]} A an integer array sorted in ascending order
    # @param {int} target an integer
    # @return {int} an integer
    def lastPosition(self, A, target):
        if not A or target is None:
            return -1

        start = 0
        end = len(A) - 1

        while start + 1 < end:  #start为啥加1？ 为啥不是小于等于； 使用 start < end 无论如何都会出现死循环
            mid = start + (end - start) // 2  #避免内存溢出

            if A[mid] < target:
                start = mid
            elif A[mid] > target:
                end = mid
            else:
                start = mid  #A[mid] == target:   #return mid 是随意返回一个中间位置，这里要求最后一个位置，所以放弃这种写法

    
        if target == A[end]: 
            return end
        elif A[start] == target:
            return start
        else:
            return -1

my_solution = Solution()
A = [1, 2, 2, 4, 5, 5]
target = 2
result = my_solution.lastPosition(A, target)
print('result is',result)

585  山脉序列中的最大值
 

class Solution:
    # @param {int[]} nums a mountain sequence which increase firstly and then decrease
    # @return {int} then mountain top
    def mountainSequence(self, nums):
        # Write your code here
        left, right = 0, len(nums) - 1
        while left + 1 < right:
            m1 = left + (right - left) // 2  # m1 is middle
            #m1 = right - (right - left) // 2
            m2 = right - (right - m1) // 2      #m2 = (right + m1)//2 是右侧和数组中点的中点
            #m2 = (right + m1)//2  #这种写法会报错
            if nums[m1] < nums[m2]:
                left = m1 + 1
            elif nums[m1] > nums[m2]:
                right = m2 - 1
            else:
                left = m1
                right = m2
            
        return max(nums[left], nums[right])

my_solution = Solution()
A = [1, 2, 4, 8, 6, 3]
result = my_solution.mountainSequence(A)
print('result is',result)

 

认识你是我们的缘分，同学，等等，记得关注我。

 

微信扫一扫
关注该公众号