算法：堆（优先队列）

堆（优先队列）分为最大堆和最小堆。

python实现

class HEAPQ:
	# 最小堆
    def __init__(self, l):
        self.l = l
        self.build()

    def build(self):
        n = len(self.l)
        end = n // 2
        for i in range(end, -1, -1):
            self.update(i)

    def update(self, i):
        l = self.l
        n = len(l)
        idx = i
        if 2 * i + 1 < n and l[2 * i + 1] < l[idx]:
            idx = 2 * i + 1
        if 2 * i + 2 < n and l[2 * i + 2] < l[idx]:
            idx = 2 * i + 2
        if idx != i:
            l[i], l[idx] = l[idx], l[i]
            self.update(idx)

    def push(self, x) -> int:
        l = self.l
        l.append(x)
        i = len(l)-1
        while i != 0:
            parent = (i-1) // 2
            # 父节点大于 则上浮
            if l[parent] > l[i]:
                l[parent], l[i] = l[i], l[parent]
                i = parent
            else:
                break

    def pop(self):
        l = self.l
        n = len(l)
        l[0], l[n - 1] = l[n - 1], l[0]
        t = l.pop()
        self.update(0)
        return t

    def top(self):
        return self.l[0]

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

给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。
请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。

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

面试题 17.09. 第 k 个数

有些数的素因子只有 3，5，7，请设计一个算法找出第 k 个数。注意，不是必须有这些素因子，而是必须不包含其他的素因子。例如，前几个数按顺序应该是 1，3，5，7，9，15，21。
面试题 17.09. 第 k 个数

class Solution:
    def getKthMagicNumber(self, k: int) -> int:
        l = [1]
        ss = set()
        tt = (3,5,7)
        for i in range(1,k):
            t = heapq.heappop(l)
            for x in tt:
                if t*x not in ss:
                    heapq.heappush(l, t*x)
                    ss.add(t*x)
        return l[0]

面试题 17.20. 连续中值

随机产生数字并传递给一个方法。你能否完成这个方法，在每次产生新值时，寻找当前所有值的中间值（中位数）并保存。
中位数是有序列表中间的数。如果列表长度是偶数，中位数则是中间两个数的平均值。

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

设计一个支持以下两种操作的数据结构：
void addNum(int num) - 从数据流中添加一个整数到数据结构中。
double findMedian() - 返回目前所有元素的中位数。
面试题 17.20. 连续中值

class MedianFinder:

    def __init__(self):
        self.max_heapq = []  # 最大堆个数大于等于最小堆
        self.min_heapq = []
    def addMax(self, l, x):
        l.append(x)
        n = len(l)
        start = n-1
        while start > 0:
            p = (start-1)//2
            if l[p] < l[start]:
                l[p], l[start] = l[start],l[p]
                start = p
            else:
                break

    def addMin(self, l, x):
        l.append(x)
        n = len(l)
        start = n-1
        while start > 0:
            p = (start-1)//2
            if l[p] > l[start]:
                l[p], l[start] = l[start],l[p]
                start = p
            else:
                break
    def updateMax(self, l,i, n):
        idx = i
        if i*2+1<n and l[2*i+1] > l[i]:
            idx = i*2+1
        if i*2+2<n and l[2*i+2] > l[idx]:
            idx = i*2+2
        if idx!=i:
            l[idx], l[i] = l[i], l[idx]
            self.updateMax(l, idx, n)
    def updateMin(self, l,i, n):
        idx = i
        if i*2+1<n and l[2*i+1] < l[i]:
            idx = i*2+1
        if i*2+2<n and l[2*i+2] < l[idx]:
            idx = i*2+2
        if idx!=i:
            l[idx], l[i] = l[i], l[idx]
            self.updateMin(l, idx, n)
    def popMax(self, l):
        n = len(l)
        l[0], l[n-1] = l[n-1], l[0]
        t = l.pop()
        self.updateMax(l, 0, n-1)
        return t
    def popMin(self, l):
        n = len(l)
        l[0], l[n-1] = l[n-1], l[0]
        t = l.pop()
        self.updateMin(l, 0, n-1)
        return t

    def addNum(self, num: int) -> None:
        if not self.max_heapq:
            self.max_heapq.append(num)
            return
        if num <= self.max_heapq[0]:
            self.addMax(self.max_heapq, num)
        else:
            self.addMin(self.min_heapq, num)
        if len(self.min_heapq) > len(self.max_heapq):
            self.addMax(self.max_heapq, self.popMin(self.min_heapq))
        elif len(self.max_heapq)-len(self.min_heapq) >1:
            self.addMin(self.min_heapq, self.popMax(self.max_heapq))


    def findMedian(self) -> float:
        if len(self.max_heapq) == len(self.min_heapq):
            return (self.max_heapq[0] + self.min_heapq[0])/2
        else:
            return self.max_heapq[0]