秋招 hot 100刷题记录【7】

1.搜索旋转排序数组

• 代码链接
• 注意这里的重点是两次二分

class Solution(object):
    def search(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        # 时间复杂度o(logn)_想到二分法因此重点是跟哪个点进行比较
        # 1.一次二分寻找最小值的下标
        minIndex = self.finMin(nums)
        # 2.第二次二分寻找target
        # 先寻找该target在哪一段
        if target > nums[-1]:
            # 说明此时在第一段序列中
            left, right = 0, minIndex - 1
        else:
            # 在第二段上
            left, right = minIndex, len(nums) - 1
        while left <= right:
            mid = left + (right - left) / 2 
            if nums[mid] > target:
                right = mid - 1
            elif nums[mid] < target:
                left = mid + 1
            else:
                return mid
        return -1
         
    def finMin(self, nums):
        left, right = 0, len(nums) - 1
        # 1.判断旋转后的数组是否还是有序的
        if len(nums) == 1 or nums[left] < nums[right]:
            return left
        while left <= right:
            mid = (left + right) / 2
            # 此时0到mid有序 那么最小值在右边那段
            if nums[mid] >= nums[0]:
                left = mid + 1
            # 此时0到mid无序，说明mid在右边段，而mid又比mid-1大 所以最小值在左边
            elif nums[mid] > nums[mid - 1]:
                right = mid - 1
            else:
                return mid
        return left

2.寻找两个正序数组的中位数

• 调用了库函数，暂时没有其他想法
• 代码链接

class Solution(object):
    def findMedianSortedArrays(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: float
        """
        nums = nums1 + nums2
        n = len(nums)
        nums = sorted(nums)
        if n <= 1:
            return nums[0]
        left = 0
        if n % 2 == 0:
            while left <= n/2:
                left += 1
            return (nums[left - 2] +nums[left -1])/ 2.0
        else:
            while left < n/2:
                left += 1
            return nums[left]

3.有效的括号

• 代码链接

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        stack = []
        if len(s) % 2 !=0:
            return False
        for ch in s:
            if ch == "(":
                stack.append(")")
            elif ch == "{":
                stack.append("}")
            elif ch == "[":
                stack.append("]")
            elif ch in ["}","]",")"]:
                if not stack: # 注意这里需要判断此时栈是否为空
                    return False
                elif stack.pop() != ch:
                    return False
        if not stack:
            return True
        else:
            return False

4.最小栈

• 代码链接

class MinStack(object):
    # 最小栈跟普通的栈的区别是检索的最小值的时候是常数时间
    def __init__(self):
        self.stack = []

    def push(self, val):
        """
        :type val: int
        :rtype: None
        """
        if not self.stack:
            self.stack.append((val, val))
        else:
            self.stack.append((val, min(self.stack[-1][1], val)))


    def pop(self):
        """
        :rtype: None
        """
        # 注意的是每一次元组中保留的都是基于当前栈的最小值 而不会更新之前的
        self.stack.pop()


    def top(self):
        """
        :rtype: int
        """
        return self.stack[-1][0] # 返回栈顶元素


    def getMin(self):
        """
        :rtype: int
        """
        return self.stack[-1][1]



# 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()

5.字符串解码

• 代码链接

class Solution(object):
    def decodeString(self, s):
        """
        :type s: str
        :rtype: str
        """
        # 时间复杂度 O(N)，递归会更新索引，因此实际上还是一次遍历 s；
        # 空间复杂度 O(N)，极端情况下递归深度将会达到线性级别。

        stack, res, multi = [], "", 0
        for c in s:
            if "0" <= c <= "9":
                multi = multi * 10 + int(c) 
                # 注意题目说正整数的范围在1到300 所以这里处理的是连续整数
            elif c == "[":
                stack.append([multi, res])
                res, multi = "", 0
            elif c == "]":
                cur_multi, cur_res = stack.pop()
                res = cur_res + cur_multi * res
            else:
                res += c
        return res