堆栈算法模板

动态维护中位数一般都是用双堆解决 – 同理:动态维护第K大数

295. 数据流的中位数

难度困难800收藏分享切换为英文接收动态反馈

中位数是有序整数列表中的中间值。如果列表的大小是偶数，则没有中间值，中位数是两个中间值的平均值。

• 例如 arr = [2,3,4] 的中位数是 3 。
• 例如 arr = [2,3] 的中位数是 (2 + 3) / 2 = 2.5 。

实现 MedianFinder 类:

• MedianFinder() 初始化 MedianFinder 对象。
• void addNum(int num) 将数据流中的整数 num 添加到数据结构中。
• double findMedian() 返回到目前为止所有元素的中位数。与实际答案相差 10-5 以内的答案将被接受。

示例 1：

输入
["MedianFinder", "addNum", "addNum", "findMedian", "addNum", "findMedian"]
[[], [1], [2], [], [3], []]
输出
[null, null, null, 1.5, null, 2.0]

解释
MedianFinder medianFinder = new MedianFinder();
medianFinder.addNum(1);    // arr = [1]
medianFinder.addNum(2);    // arr = [1, 2]
medianFinder.findMedian(); // 返回 1.5 ((1 + 2) / 2)
medianFinder.addNum(3);    // arr[1, 2, 3]
medianFinder.findMedian(); // return 2.0

提示:

• -105 <= num <= 105
• 在调用 findMedian 之前，数据结构中至少有一个元素
• 最多 5 * 104 次调用 addNum 和 findMedian

我自己写的，逻辑还是比较简单清晰：

使用两个heap：maxheap 和 minheap，把比 median 小的放在 maxheap 里，把比 median 大的放在 minheap 里。median 单独放在一个变量里。 每次新增一个数的时候，先根据比当前的 median 大还是小丢到对应的 heap 里。 丢完以后，再处理左右两边的平衡性:

1. 如果左边太少了，就把 median 丢到左边，从右边拿一个最小的出来作为 median。
2. 如果右边太少了，就把 median 丢到右边，从左边拿一个最大的出来作为新的 median。

import heapq


class MedianFinder:

    def __init__(self):
        self.median = None
        self.maxheap = []
        self.minheap = []

    def addNum(self, num: int) -> None:
        self.add(num)

    def findMedian(self) -> float:
        return self.median

    def add(self, num):
        if self.median is None:
            self.median = num
            self.minheap = [num]
            return

        if num < self.median:
            heapq.heappush(self.maxheap, -num)
        else:
            heapq.heappush(self.minheap, num)

        # balanace
        if len(self.maxheap) > len(self.minheap) + 1:
            heapq.heappush(self.minheap, -heapq.heappop(self.maxheap))

        if len(self.maxheap) + 1 < len(self.minheap):
            heapq.heappush(self.maxheap, -heapq.heappop(self.minheap))

        max_heap_len, min_heap_len = len(self.maxheap), len(self.minheap)
        if max_heap_len == min_heap_len:
            self.median = (-self.maxheap[0] + self.minheap[0]) / 2
        elif max_heap_len > min_heap_len:
            self.median = -self.maxheap[0]
        else:
            self.median = self.minheap[0]

81. 数据流中位数

中文

English

数字是不断进入数组的，在每次添加一个新的数进入数组的同时返回当前新数组的中位数。

样例

样例1

输入: [1,2,3,4,5]
输出: [1,1,2,2,3]
样例说明：
[1] 和 [1,2] 的中位数是 1.
[1,2,3] 和 [1,2,3,4] 的中位数是 2.
[1,2,3,4,5] 的中位数是 3.

样例2

输入: [4,5,1,3,2,6,0]
输出: [4,4,4,3,3,3,3]
样例说明：
[4], [4,5] 和 [4,5,1] 的中位数是 4.
[4,5,1,3], [4,5,1,3,2], [4,5,1,3,2,6] 和 [4,5,1,3,2,6,0] 的中位数是 3.

挑战

时间复杂度为O(nlogn)

说明

中位数的定义：

• 这里的中位数不等同于数学定义里的中位数。
• 中位数是排序后数组的中间值，如果有数组中有n个数，则中位数为
• 比如：数组A=[1,2,3]的中位数是2，数组A=[1,19]的中位数是1。

使用双队列，一个minheap，一个maxheap，还是比较恶心！！！

import heapq


class Solution:
    """
    @param nums: A list of integers
    @return: the median of numbers
    """

    def medianII(self, nums):
        # write your code here
        ans = nums[:1]
        if len(nums) <= 1:
            return ans

        max_heap = []
        min_heap = [nums[0]]

        for i in range(1, len(nums)):
            m, n = len(max_heap), len(min_heap)
            if m < n:
                r = min_heap[0]
                if nums[i] > r:
                    val = heapq.heappop(min_heap)
                    heapq.heappush(max_heap, -val)
                    heapq.heappush(min_heap, nums[i])
                    ans.append(-max_heap[0])
                else:
                    heapq.heappush(max_heap, -nums[i])
                    ans.append(-max_heap[0])
            elif m == n:
                l = -max_heap[0]
                r = min_heap[0]

                if nums[i] <= l:
                    val = -heapq.heappop(max_heap)
                    heapq.heappush(min_heap, val)
                    heapq.heappush(max_heap, -nums[i])
                    ans.append(val)
                elif nums[i] <= r:
                    heapq.heappush(min_heap, nums[i])
                    ans.append(nums[i])
                else:
                    heapq.heappush(min_heap, nums[i])
                    ans.append(min_heap[0])

        return ans

把比 median 小的放在 maxheap 里，把比 median 大的放在 minheap 里。median 单独放在一个变量里。 每次新增一个数的时候，先根据比当前的 median 大还是小丢到对应的 heap 里。 丢完以后，再处理左右两边的平衡性:

1. 如果左边太少了，就把 median 丢到左边，从右边拿一个最小的出来作为 median。
2. 如果右边太少了，就把 median 丢到右边，从左边拿一个最大的出来作为新的 median。

import heapq


class Solution:
    """
    @param nums: A list of integers
    @return: the median of numbers
    """
    def medianII(self, nums):
        if not nums:
            return []
            
        self.median = nums[0]
        self.maxheap = []
        self.minheap = []
        
        medians = [nums[0]]
        for num in nums[1:]:
            self.add(num)
            medians.append(self.median)
            
        return medians

    def add(self, num):
        if num < self.median:
            heapq.heappush(self.maxheap, -num)
        else:
            heapq.heappush(self.minheap, num)
            
        # balanace
        if len(self.maxheap) > len(self.minheap):
            heapq.heappush(self.minheap, self.median)
            self.median = -heapq.heappop(self.maxheap)
        elif len(self.maxheap) + 1 < len(self.minheap):
            heapq.heappush(self.maxheap, -self.median)
            self.median = heapq.heappop(self.minheap)

python heapq模块 删除中间某一特定参数

python内的heapq提供heappush,heappop两个方法，然而对于 删除 中间的某个参数没有给出相应的方法：

from heapq import heappush, heappop, _siftdown, _siftup
# heap data structure, (value, key), value is used for sorting and key used for identifying
def heapdelete(heap,i):
    nodeValue = heap[i];leafValue = heap[-1];
    if nodeValue == leafValue:
        heap.pop(-1)
    elif nodeValue <= leafValue: # similar to heappop
        heap[i], heap[-1] = heap[-1], heap[i]
        minimumValue = heap.pop(-1)
        if heap != []:
            _siftup(heap, i)
    else: # similar to heappush
        heap[i], heap[-1] = heap[-1], heap[i]
        minimumValue = heap.pop(-1)
        _siftdown(heap, 0, i)

360. 滑动窗口的中位数

中文

English

给定一个包含 n 个整数的数组，和一个大小为 k 的滑动窗口,从左到右在数组中滑动这个窗口，找到数组中每个窗口内的中位数。(如果数组个数是偶数，则在该窗口排序数字后，返回第 N/2 个数字。)

样例

Example 1:

Input:
[1,2,7,8,5]
3
Output:
[2,7,7]

Explanation:
At first the window is at the start of the array like this `[ | 1,2,7 | ,8,5]` , return the median `2`;
then the window move one step forward.`[1, | 2,7,8 | ,5]`, return the median `7`;
then the window move one step forward again.`[1,2, | 7,8,5 | ]`, return the median `7`;

Example 2:

Input:
[1,2,3,4,5,6,7]
4
Output:
[2,3,4,5]

Explanation:
At first the window is at the start of the array like this `[ | 1,2,3,4, | 5,6,7]` , return the median `2`;
then the window move one step forward.`[1,| 2,3,4,5 | 6,7]`, return the median `3`;
then the window move one step forward again.`[1,2, | 3,4,5,6 | 7 ]`, return the median `4`;
then the window move one step forward again.`[1,2,3,| 4,5,6,7 ]`, return the median `5`;

挑战

时间复杂度为 O(nlog(n))

使用 HashHeap。即一个 Hash + Heap。 Hash 的 key 是 Heap 里的每个元素，值是这个元素在 Heap 中的下标。

要做这个题首先需要先做一下 Data Stream Median。这个题是只在一个集合中增加数，不删除数，然后不断的求中点。 Sliding Window Median，就是不断的增加数，删除数，然后求中点。比 Data Stream Median 难的地方就在于如何支持删除数。

因为 Data Stream Median 的方法是用 两个 Heap，一个 max heap，一个min heap。所以删除的话，就需要让 heap 也支持删除操作。 由于 Python 的 heapq 并不支持 logn 时间内的删除操作，因此只能自己实现一个 hash + heap 的方法。

总体时间复杂度 O(nlogk)，n是元素个数，k 是 window 的大小。
算了，遇到这种题目就自认倒霉吧！！！

class HashHeap:
    
    def __init__(self, desc=False):
        self.hash = dict()
        self.heap = []
        self.desc = desc
        
    @property
    def size(self):
        return len(self.heap)
        
    def push(self, item):
        self.heap.append(item)
        self.hash[item] = self.size - 1
        self._sift_up(self.size - 1)
        
    def pop(self):
        item = self.heap[0]
        self.remove(item)
        return item
    
    def top(self):
        return self.heap[0]
        
    def remove(self, item):
        if item not in self.hash:
            return
            
        index = self.hash[item]
        self._swap(index, self.size - 1)
        
        del self.hash[item]
        self.heap.pop()
        
        # in case of the removed item is the last item
        if index < self.size:
            self._sift_up(index)
            self._sift_down(index)

    def _smaller(self, left, right):
        return right < left if self.desc else left < right

    def _sift_up(self, index):
        while index != 0:
            parent = index // 2
            if self._smaller(self.heap[parent], self.heap[index]):
                break
            self._swap(parent, index)
            index = parent
    
    def _sift_down(self, index):
        if index is None:
            return
        while index * 2 < self.size:
            smallest = index
            left = index * 2
            right = index * 2 + 1
            
            if self._smaller(self.heap[left], self.heap[smallest]):
                smallest = left
                
            if right < self.size and self._smaller(self.heap[right], self.heap[smallest]):
                smallest = right
                
            if smallest == index:
                break
            
            self._swap(index, smallest)
            index = smallest
        
    def _swap(self, i, j):
        elem1 = self.heap[i]
        elem2 = self.heap[j]
        self.heap[i] = elem2
        self.heap[j] = elem1
        self.hash[elem1] = j
        self.hash[elem2] = i
    
class Solution:
    """
    @param nums: A list of integers
    @param k: An integer
    @return: The median of the element inside the window at each moving
    """
    def medianSlidingWindow(self, nums, k):
        if not nums or len(nums) < k:
            return []
            
        self.maxheap = HashHeap(desc=True)
        self.minheap = HashHeap()
        
        for i in range(0, k - 1):
            self.add((nums[i], i))
            
        medians = []
        for i in range(k - 1, len(nums)):
            self.add((nums[i], i))
            # print(self.maxheap.heap, self.median, self.minheap.heap)
            medians.append(self.median)
            self.remove((nums[i - k + 1], i - k + 1))
            # print(self.maxheap.heap, self.median, self.minheap.heap)
            
        return medians
            
    def add(self, item):
        if self.maxheap.size > self.minheap.size:
            self.minheap.push(item)
        else:
            self.maxheap.push(item)
            
        if self.maxheap.size == 0 or self.minheap.size == 0:
            return
            
        if self.maxheap.top() > self.minheap.top():
            self.maxheap.push(self.minheap.pop())
            self.minheap.push(self.maxheap.pop())
        
    def remove(self, item):
        self.maxheap.remove(item)
        self.minheap.remove(item)
        if self.maxheap.size < self.minheap.size:
            self.maxheap.push(self.minheap.pop())
        
    @property
    def median(self):
        return self.maxheap.top()[0]

stack的算法

12. 带最小值操作的栈

中文

English

实现一个栈, 支持以下操作:

• push(val) 将 val 压入栈
• pop() 将栈顶元素弹出, 并返回这个弹出的元素
• min() 返回栈中元素的最小值

要求 O(1) 开销.

样例

样例 2:

输入: 
  push(1)
  min()
  push(2)
  min()
  push(3)
  min()
输出: 
  1
  1
  1

注意事项

保证栈中没有数字时不会调用 min()

class MinStack:
    
    def __init__(self):
        # do intialization if necessary
        self.stack = collections.deque()
        
    """
    @param: number: An integer
    @return: nothing
    """
    def push(self, number):
        # write your code here
        if self.stack:
            min_val = min(self.min(), number)
        else:
            min_val = number
            
        self.stack.append((number, min_val))

    """
    @return: An integer
    """
    def pop(self):
        # write your code here
        return self.stack.pop()[0]

    """
    @return: An integer
    """
    def min(self):
        # write your code here
        return self.stack[-1][1]

 这种题目还是要分析下才能快速写出来！！！差点就被唬住了！！！

575. 字符串解码

中文

English

给出一个表达式 s，此表达式包括数字，字母以及方括号。在方括号前的数字表示方括号内容的重复次数(括号内的内容可以是字符串或另一个表达式)，请将这个表达式展开成一个字符串。

样例

样例1

输入: S = abc3[a]
输出: "abcaaa"

样例2

输入: S = 3[2[ad]3[pf]]xyz
输出: "adadpfpfpfadadpfpfpfadadpfpfpfxyz"

挑战

你可以不通过递归的方式完成展开吗？

注意事项

数字只能出现在“[]”前面。

LETTERS = set("abcdefghijklmnopqrstuvwxyz")
NUMS = set("0123456789")

        
class Solution:
    """
    @param s: an expression includes numbers, letters and brackets
    @return: a string
    """
    def expressionExpand(self, s):
        # write your code here
        # S = 3[2[ad]3[pf]]xyz
        # = 3 f(2[ad]3[pf]) + xyz
        # =     2*f(ad) + 3*f(pf) 
        self.braces = self.calc_brace_pos(s)
        
        return self.helper(s, 0, len(s)-1)
    
    def helper(self, s, start, end):
        ans = ""
        digit = 0
        i = start
        while i <= end:
            c = s[i].lower()
            if c in NUMS:
                digit = 10*digit + (ord(c) - ord('0'))
                i += 1
            elif c in LETTERS:
                ans += s[i]
                digit = 0
                i += 1
            elif c == '[': # digit is over
                ans += self.helper(s, i+1, self.braces[i]-1)*digit
                digit = 0
                i = self.braces[i]+1

        return ans
            
    def calc_brace_pos(self, s):
        brace_stack = []
        ans = {}
        for i,c in enumerate(s):
            if c == '[':
                brace_stack.append(i)
            elif c == ']':
                ans[brace_stack.pop()] = i
        
        return ans

递归的还可以写写，非递归的，状态机太复杂了！！！

• 改成非递归需要栈

• 数字和字符都push
– 见到“[”push当前数字入栈 – 字符直接压栈

• 见到“]”就pop字符直到碰到数字A – 这些字符组成的字符串重复A次

把所有字符一个个放到 stack 里，当碰到 "]" 的时候，就从 stack 把对应的字符串和重复次数找到，展开，然后再丢回 stack 里，

class Solution:
    """
    @param s: an expression includes numbers, letters and brackets
    @return: a string
    """
    def expressionExpand(self, s):
        stack = []
        for c in s:
            if c == ']':
                strs = []
                while stack and stack[-1] != '[':
                    strs.append(stack.pop())
                
                # skip '['
                stack.pop()
                
                repeats = 0
                base = 1
                while stack and stack[-1].isdigit():
                    repeats += (ord(stack.pop()) - ord('0')) * base
                    base *= 10
                stack.append(''.join(reversed(strs)) * repeats)
            else:
                stack.append(c)
        
        return ''.join(stack)

394. 字符串解码

给定一个经过编码的字符串，返回它解码后的字符串。

编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。

你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。

此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。

示例 1：

输入：s = "3[a]2[bc]"
输出："aaabcbc"

示例 2：

输入：s = "3[a2[c]]"
输出："accaccacc"

示例 3：

输入：s = "2[abc]3[cd]ef"
输出："abcabccdcdcdef"

示例 4：

输入：s = "abc3[cd]xyz"
输出："abccdcdcdxyz"

leetcode上我自己写的：

class Solution:
    def decodeString(self, s: str) -> str:
        stack = []
        i = 0
        n = len(s)
        while i < n:
            if 'a' <= s[i] <= 'z':
                start = i
                while i + 1 < n and 'a' <= s[i + 1] <= 'z':
                    i += 1
                string = s[start:i+1]
                stack.append(string)
            elif '0' <= s[i] <= '9':
                start = i
                while i + 1 < n and '0' <= s[i + 1] <= '9':
                    i += 1
                num = s[start:i+1]
                stack.append(int(num))
            elif s[i] == '[':
                stack.append(s[i])
            elif s[i] == ']':
                arr = []
                while stack[-1] != '[':
                    arr.append(stack.pop())
                stack.pop()
                num = stack.pop()
                dup = ("".join(arr[::-1])) * num
                stack.append(dup)
            else:
                break

            i += 1

        return "".join(stack)

 使用一个stack搞定的。

122. 直方图最大矩形覆盖

中文

English

给出的n个非负整数表示每个直方图的高度，每个直方图的宽均为1，在直方图中找到最大的矩形面积。

样例

Example 1:

Input：[2,1,5,6,2,3]
Output：10
Explanation：
The third and fourth rectangular truncated rectangle has an area of 2*5=10.

Example 2:

Input：[1,1]
Output：2
Explanation：
The first and second rectangular truncated rectangle has an area of 2*1=2.

class Solution:
    
    def largestRectangleArea(self, heights) -> int:
        
        heights = [0] + heights + [0]
        stack, max_area = [], 0
        
        for hi_index, height in enumerate(heights):
            
            while stack and height < heights[stack[-1]]:
                
                popped_index = stack.pop()
                lo_index = stack[-1] + 1 

                area = heights[popped_index] * (hi_index - lo_index)
                max_area = max(max_area, area)
            
            stack.append(hi_index)
        
        return max_area