秋招 hot 100 刷题记录【8】

1.每日温度

• 代码链接

class Solution(object):
    def dailyTemperatures(self, temperatures):
        """
        :type temperatures: List[int]
        :rtype: List[int]
        """
        # 单调栈解题思路 在o(n)的时间复杂度内求出数组各元素右侧第一个更大的元素&下标
        if len(temperatures) <= 1:
            return [0] * len(temperatures)
        answer = [0] * len(temperatures)
        stack = [] # 存储元素的下标 维护一个单调减的栈
        max_value = temperatures[0]
        for i in range(len(temperatures)):
            while stack and temperatures[i] > temperatures[stack[-1]]:
                prevI = stack.pop()
                answer[prevI] = i - prevI # 存储的为差值
             
            stack.append(i)
        return answer

2.柱状图中最大矩形

• 代码链接
• 注意 单调栈的运用以及其的初始化下标

class Solution(object):
    def largestRectangleArea(self, heights):
        """
        :type heights: List[int]
        :rtype: int
        """
        # 思路：两次单调栈
        # 面积 = （右边小于h的最近下标 - 左边小于h的最近下表 - 1）* h
        if len(heights) <= 1:
            return heights[0]
        
        left = [-1] * len(heights) # 左边小于h的坐标初始化为-1
        right = [len(heights)] * len(heights) # 右边小于h的坐标初始化为len(heights)
        stack = []
        for i in range(len(heights)):
            while stack and heights[i] < heights[stack[-1]]:
                prevI = stack.pop()
                right[prevI] = i
            stack.append(i)
        stack = []
        for i in range(len(heights) - 1, -1, -1):
            while stack and heights[i] < heights[stack[-1]]:
                prevI = stack.pop()
                left[prevI] = i
            stack.append(i)
        ans = 0
        for l, r, h in zip(left, right, heights):
            print(l,r,h)
            ans = max(ans, (r - l - 1) * h)
        return ans

3.数组中最大的第K个元素

• 代码链接

class Solution(object):
    def findKthLargest(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        # 快速排序
        # 时间复杂度 O(N) ： 其中 N 为数组元素数量。
        # 空间复杂度 O(logN) ： 划分函数的平均递归深度为 O(logN) 。

        def quick_select(nums, k):
            pivot = random.choice(nums) # 选择基准数 也就是哨兵
            big, equal, small = [], [], []
            # 基于哨兵 对数组进行划分到 small big equal 中去
            for num in nums:
                if num > pivot:
                    big.append(num)
                elif num < pivot:
                    small.append(num)
                else:
                    equal.append(num)
            # 判断第K大的树在哪个数组中进行划分
            if k <= len(big):
                return quick_select(big, k)
            # 此时第k大的一定在其中
            if len(nums) - len(small) < k:
                return quick_select(small, k - (len(nums) - len(small)))
            # 此时第k大的在equal中 那么就返回哨兵元素
            return pivot
        return quick_select(nums, k)

4.前K个高频元素

• 对于 topk 问题：最大堆求topk小，最小堆求 topk 大。
  • topk小：构建一个 k 个数的最大堆，当读取的数小于根节点时，替换根节点，重新塑造最大堆
  • topk大：构建一个 k 个数的最小堆，当读取的数大于根节点时，替换根节点，重新塑造最小堆
• 代码链接

class Solution(object):
    def topKFrequent(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """

        # 对于出现频率题 一定要想到用哈希表存储频率
        map_ = {}
        for num in nums:
            map_[num] = map_.get(num, 0) + 1
        
        # 构建小顶堆维护出现频率最高的k个数字
        # 小顶堆 顶点是最小的元素
        minHeap = []
        for num, freq in map_.items():
            # 注意这里的小顶堆我们只要维护k个数字
            if len(minHeap) < k:
                heapq.heappush(minHeap, (freq, num)) 
                # (freq, num) 意思是优先级是freq，节点数据是num
            # 如果此时要插入的节点freq大于堆顶元素，则加入新节点替换堆顶元素
            elif freq > minHeap[0][0]:
                heapq.heappushpop(minHeap, (freq, num)) # 注意这里的方法名称
        
        topK = [num for freq,num in minHeap]
        return topK 

5.数据流的中位数

• 代码链接

class MedianFinder(object):

    def __init__(self):
        self.A = []     # 使用小顶堆存储较大的一半
        self.B = []    # 使用大顶堆存储较小的一半

    def addNum(self, num):
        """
        :type num: int
        :rtype: None
        """
        #  如果是奇数长度，中位数保存在A中（高半部分），
        # 所以必须先放进B中比较，再从B中弹出至A，使得A中始终多一个数字

        # 说明A中多了元素 要往B中添加
        if len(self.A) != len(self.B):
            heappush(self.A, num)
            # 实现 大顶堆 方法： 小顶堆的插入和弹出操作均将元素 取反 即可。
            heappush(self.B, - heappop(self.A))
        else:
            # 往B中加入元素的时候注意取反
            heappush(self.B, -num)
            heappush(self.A , - heappop(self.B))

    def findMedian(self):
        """
        :rtype: float
        """
        # 奇数偶数的情况分开
        # 这里用self.A[0] - self.B[0]的原因是B是大顶堆 元素存储的时候取反了
        return self.A[0] if len(self.A) != len(self.B) else (self.A[0] - self.B[0]) / 2.0



# Your MedianFinder object will be instantiated and called as such:
# obj = MedianFinder()
# obj.addNum(num)
# param_2 = obj.findMedian()