力扣不能断啊 154 -164

哈哈哈哈  不是10道题 而是很多题被锁了 

 

154: 寻找旋转数组的最小值 

 

因为之前好像见过类似的 知道是二分 

找有序段 

left mid right n minnum 我也只有这五个变量名啊 而且都是必须的好嘛。
结果空间被百分之95的人击败
时间击败了72的人 还行吧。

下面说说思路 就是二分法嘛
我感觉已经摸到了二分法的精髓
就是看左右端点值 和中间值的情况 做出区间的改变。

中间和两端比较 有几种情况呢 ？ 9种啊 3*3嘛

class Solution:
    def findMin(self, nums: List[int]) -> int:
        left = 0
        n = len(nums)
        right = n-1
        while left <= right:
            mid = (left +right) //2
            if mid == n-1 or mid == 0:
                return min(nums[left],nums[right])
            if nums[mid] < nums[mid+1] and nums[mid] < nums[mid-1]:
                return nums[mid]
            if nums[mid] > nums[left]:       #当大于左端点时
                if nums[mid] > nums[right]:            # 大左 又 大右 说明最小值在右边
                    left = mid + 1
                else:                                  #大于左边 但是小于等于右边  说明最小值就是最左边的值
                    return nums[left]
            elif nums[mid] == nums[left]:    #当等于左端点时。
                if nums[mid] > nums[right]:            # 等左 又 大右 说明最小值在右边
                    left = mid + 1
                elif nums[mid] == nums[right]:         # 等左 又 等右 没法判断 遍历吧。
                    minnum = nums[left]
                    for i in range(left,right+1):
                        if minnum > nums[i]:
                            minnum = nums[i]
                    return minnum
                else:                                  #等于左边 但是小于右边  说明最小值就是最左边的值  
                    return nums[left]
            else:                            #当小于左端点时。
                right = mid                            #此时不可能大于右端点，
                                                       #小左又小于等于右时，只能是左边 或者就是mid本身。




作者：yizhu-jia
链接：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/solution/wo-bu-li-jie-wei-shi-yao-wo-de-kong-jian-22e8/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 

155: 最小栈 

难点在于pop实现 我懒了 无脑的找 

 

class MinStack:

    def __init__(self):
        self.stack = []
        self.minNum = float('inf')

    def push(self, val: int) -> None:
        self.stack.append(val)
        if val < self.minNum:
            self.minNum = val

    def pop(self) -> None:
        topNum = self.stack.pop()
        if topNum == self.minNum:
            minNum = float('inf')
            for each in self.stack:
                if each < minNum:
                    minNum = each
            self.minNum = minNum
        return topNum

    def top(self) -> int:
        topNum = self.stack[-1]
        return topNum

    def getMin(self) -> int:
        return self.minNum



# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(val)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

作者：yizhu-jia
链接：https://leetcode-cn.com/problems/min-stack/solution/zen-yao-shi-xian-pop-ni-xuan-de-shi-zui-tnisw/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

160: 很多题被锁了 沃日 

相交链表 

先找到长度差 

然后让长的那个先走长度差 的长度 

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        def listLen(head):
            num = 0 
            while head != None:
                head = head.next
                num  += 1
            return num
        


        diff = listLen(headA) - listLen(headB)
        if diff > 0 :
            p = headA
            q = headB
        else:
            p = headB
            q = headA           #p是长的那个
        diff =abs(diff)
        while diff > 0 :
            p = p.next
            diff -= 1
            
        while  p != None :
            if p == q:
                return p            
            p = p.next
            q = q.next

        return None
        

作者：yizhu-jia
链接：https://leetcode-cn.com/problems/intersection-of-two-linked-lists/solution/hao-duo-ti-bei-suo-liao-can-nian-by-yizh-2rs7/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

162 寻找峰值 

特殊情况比较麻烦 

但是看到时间复杂度就应该想到二分法
二分法就是找结果可能在的区间。
就是比较三个点的值。
当中间 大于左 小于右 结果肯定在左边
大于左 大于右 结果不确定 要再看两个点 左中点 和右中点 如果正中点大于两边两个中点 说明结果在左右中点之间
如果正中点小于哪一边 说明解就在哪一边
小于左 大于右 在右边
小于左 小于右 左右都有解

get 判断比较麻烦 等号一定是加在大于等于左上 因为向下取整很容易出现mid = left 的情况

class Solution:
    def findPeakElement(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 1:
            return 0
        left = 0
        right = n-1
        while left <= right:
            mid = (left + right )//2
            if mid == 0 :
                if nums[0] > nums[1]:
                    return 0
                else:
                    return 1
            if mid == n-1:
                if nums[mid] > nums[mid-1]:
                    return n-1
                else:
                    return n-2
            if nums[mid] > nums[mid-1] and nums[mid] > nums[mid+1]:
                return mid
            if nums[mid] >= nums[left] :
                if nums[mid] > nums[right]:
                    lmid = (mid + left) //2
                    rmid = (mid + right) //2
                    if nums[lmid] > nums[mid]:
                        right = mid-1
                    elif nums[rmid] > nums[mid]:
                        left = mid + 1
                    else:
                        left = lmid
                        right = rmid
                else:
                    left = mid +1
            else:
                right = mid -1

作者：yizhu-jia
链接：https://leetcode-cn.com/problems/find-peak-element/solution/ai-er-fen-fa-jiu-shi-te-shu-qing-kuang-n-rxjw/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

164 最大间距 好家伙 我只接sorted排序 

 

class Solution:
    def maximumGap(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 1:
            return 0
        nums = sorted(nums)
        rel = float('-inf')
        for i,each in enumerate(nums[1:]):
            if each - nums[i] > rel:
                rel = each - nums[i]
        return rel 


作者：yizhu-jia
链接：https://leetcode-cn.com/problems/maximum-gap/solution/sorted-by-yizhu-jia-sw82/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。