数组中的第K个最大元素

题目链接：https://leetcode-cn.com/problems/kth-largest-element-in-an-array/
题目描述：
在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

说明:

你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。

解答一

通过维护一个大顶堆，来寻找第K大元素

import java.util.NoSuchElementException;
class Solution {
    int[] heap;
    int heapSize;
    public int findKthLargest(int[] nums, int k) {
        int result=0;
        heap = new int[nums.length];
        heapSize=0;
        //将数组中元素插入堆，形成一个大顶堆
        for(int i=0;i<nums.length;i++) {
            insert(heap,nums[i]);
        }
        //通过每次删除大顶堆中的最大元素找到第k大
        for(int i=0;i<k;i++) {
            result=delete(heap,0);
        }
        return result;
    }
    //大顶堆的插入
    public void insert(int[] heap,int x) {
        if(heapSize >= heap.length) {
            throw new NoSuchElementException("Heap is full, No space to insert new element");
        }
        //每次都先将插入元素放到堆数组的末尾
        heap[heapSize]=x;
        heapSize++;
        //再通过heapifyUp将插入的元素放到合适的位置
        heapifyUp(heapSize-1);        
    }
    public int delete(int[] heap, int x) {
        if(heapSize<=0) {
            throw new NoSuchElementException("Heap is empty, No element to delete");
        }
        int maxValue = heap[x];
        //将堆数组末尾的元素放到堆顶位置，相当于删去堆顶元素，再通过heapifyDown来维护这个大顶堆
        heap[x]=heap[heapSize-1];
        heapSize--;
        heapifyDown(x);
        return maxValue;
    }
    public void heapifyUp(int i) {
        int insertValue = heap[i];
        //找到插入元素的合适位置i
        while(i>0 && insertValue>heap[parent(i)]){
            heap[i]=heap[parent(i)];
            i=parent(i);
        }
        heap[i]=insertValue;
    }
    public void heapifyDown(int i){
        int child;
        int temp=heap[i];
        //找到这个暂时放在堆顶的元素应该去的位置
        while(kthChild(i,1)<heapSize){
            child=maxChild(i);
            if(temp>=heap[child]) {
                break;
            }
            heap[i]=heap[child];
            i=child;
        }
        heap[i]=temp;
    }
    public int parent(int i) {
        //二叉堆中下标i的元素的父节点下标
        return (i-1)/2;
    }
    public int kthChild(int i,int k) {
        //下标i的元素的两个孩子结点的下标
        return 2*i+k;
    }
    public int maxChild(int i) {
        int leftChild=kthChild(i,1);
        int rightChild=kthChild(i,2);
        return heap[leftChild]>heap[rightChild]?leftChild:rightChild;
    }
}