LeetCode：703. Kth Largest Element in a Stream

Problem Description

Design a class to find the kth largest element in a stream. Note that it is the kth largest element in the sorted order, not the kth distinct element.

Your KthLargest class will have a constructor which accepts an integer k and an integer array nums, which contains initial elements from the stream. For each call to the method KthLargest.add, return the element representing the kth largest element in the stream.

Example:

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
Note:
You may assume that nums’ length ≥ k-1 and k ≥ 1.

题目大意

给定数字k，和一组数据，每次插入一个数，得到插入后这组数据中的第k大元素。

解题思路

维护一个大小为k的小顶堆，第k大元素，即为堆顶元素。

同样，求第k小元素时，只需要维护一个大小为k的大顶堆即可，堆顶元素即为第k小元素

数据结构：堆

堆的特点：
首先堆是一棵完全二叉树
其次，堆分为大顶堆和小顶堆

大顶堆：父节点大于两个子节点
小顶堆：父节点小于两个子节点

例如：这是一个小顶堆，假设遍历100个整数得到这个大小为14的小顶堆，则堆顶的1是这100个整数的第14大元素。

详细介绍见：https://blog.csdn.net/m0_37264516/article/details/84941656

实现代码

public class KthLargest {

    private int [] heap;//小顶堆
    private int count;//堆中元素个数
    private int max;//最大元素个数，即最大k个的小顶堆，堆顶元素为第K大元素
    
    /**
     * 初始化堆
     * @param k 求第k大元素
     * @param nums 初始数据
     */
    public KthLargest(int k, int[] nums) {
        this.count = 0;
        this.max = k;
        this.heap = new int [k+1];
        for(int i=0; i<nums.length; i++){
            insert(nums[i]);
        }
    }

    public int add(int val) {
        insert(val);
        return this.heap[1];
    }
    /**
     * 堆中插入元素
     * @param data 插入的数据
     */
    private void insert(int data) {
        //堆中数据满了，则判断是否替换堆顶元素，未满，则直接插入到堆尾
        if(this.count >= this.max){
            if(this.heap[1] < data){
                this.heap[1] = data;
            } else {
                return;
            }
            //自上而下堆化
            int i=1;
            while(true){
                int left = 2*i;
                int right = 2*i+1;
                int minPor = i;
                if(left <= this.max && this.heap[left] < data){
                    minPor = left;
                }
                if(right <= this.max && this.heap[right] < this.heap[minPor]){
                    minPor = right;
                }
                if(minPor == i) break;
                else swap(i, minPor);
                i = minPor;
            }
        } else {
            this.heap[++this.count] = data;
            int i = this.count;
            //自下而上堆化
            while(i/2 > 0 && this.heap[i] < this.heap[i/2]){
                swap(i, i/2);
                i = i/2;
            }
        }
        
    }

    /**
     * 交换两个数
     * @param i
     * @param j
     */
    private void swap(int i, int j) {
        this.heap[i] = this.heap[i] ^ this.heap[j];
        this.heap[j] = this.heap[i] ^ this.heap[j];
        this.heap[i] = this.heap[i] ^ this.heap[j];
    }

    
    public static void main(String[] args) {
        int k = 7;
        int[] arr = new int[] {-10,1,3,1,4,10,3,9,4,5,1};
        KthLargest kthLargest = new KthLargest(k, arr);
        System.out.println(kthLargest.add(3));
        System.out.println(kthLargest.add(11));
        System.out.println(kthLargest.add(22));
        System.out.println(kthLargest.add(1));
        System.out.println(kthLargest.add(55));
    }
    
}