小顶堆 | 数据流中的第K大元素

设计一个找到数据流中第K大元素的类（class）。注意是排序后的第K大元素，不是第K个不同的元素。
你的 KthLargest 类需要一个同时接收整数 k 和整数数组nums 的构造器，它包含数据流中的初始元素。每次调用 KthLargest.add，返回当前数据流中第K大的元素。

示例:

int k = 3;
int[] arr = [4,5,8,2];
KthLargest kthLargest = new KthLargest(3, arr);
kthLargest.add(3);   // returns 4
kthLargest.add(5);   // returns 5
kthLargest.add(10);  // returns 5
kthLargest.add(9);   // returns 8
kthLargest.add(4);   // returns 8

思路1

该题其实就是维护一个k个元素的小顶堆。
小顶堆:根元素为最小值
大顶堆:根元素为最大值

当插入元素时，分为三种情况
1、如果已经有k个元素。且插入的数比最小元素小。不操作
2、如果已经有k个元素，且插入的数比最小元素大，则用插入的元素替换根节点的元素，并且进行下沉，即从根节点开始，和儿子节点中的较小值进行比较，如果较小的儿子节点小于父亲节点，则交换，直到较小的节点大于父亲节点。
3、如果不足k个元素，则在堆尾插入元素，并进行上浮，即与父亲节点进行比较。如果比父亲节点小，则进行交换。

用数组构建堆时注意事项

1、未使用index = 0元素的数组的父子节点的下标关系
k=父节点的index -> 左子节点的index = 2k， 右子节点的index = 2k + 1
j = 子节点的index -> 父节点的index = j / 2

2、使用index = 0元素的数组的父子节点的下标关系
k=父节点的index -> 左子节点的index = 2k + 1， 右子节点的index = （2 + 1）k
j = 子节点的index -> 父节点的index = （j -1） / 2

参考文章:https://zhuanlan.zhihu.com/p/37968599

class KthLargest(object):

    def __init__(self, k, nums):
        """
        :type k: int
        :type nums: List[int]
        """
        self.heap = []
        self.k = k
        for x in nums:
            self.insert(x)
        
    def insert(self,num):
        if len(self.heap) == self.k and self.heap[0] > num:
            return self.heap[0]
        else:
            if len(self.heap) < self.k:
                self.heap.append(num)
                k = len(self.heap) - 1
                while(k):
                    parent = (k-1) >> 1
                    if parent >=0 and self.heap[parent] > self.heap[k]:
                        tmp = self.heap[parent]
                        self.heap[parent] = self.heap[k]
                        self.heap[k] = tmp
                        k = parent
                    else:
                        return self.heap[0]
            else:
                self.heap[0] = num
                parent = 0
                while (parent << 1) + 1 < len(self.heap):
                    k = (parent << 1) + 1
                    if k + 1 < len(self.heap) and self.heap[k+1] < self.heap[k]:
                        k = k + 1
                    if self.heap[k] < self.heap[parent]:
                        tmp = self.heap[parent]
                        self.heap[parent] = self.heap[k]
                        self.heap[k] = tmp
                        parent = k   
                    else:
                        break
            
    def add(self, val):
        """
        :type val: int
        :rtype: int
        """
        self.insert(val)
        return self.heap[0]