• 题目要求：给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。
  请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
  你必须设计并实现时间复杂度为 O(n) 的算法解决此问题。
  
• 代码及思路
  • 使用小根堆来解决，遍历数组，将元素放入堆中
  • 当堆的大小大于k时，将堆顶元素弹出
  • 最终堆中元素是数组中最大的k个元素，且堆顶是其中最小的
  • 代码

class Solution {
    
    public int findKthLargest(int[] nums, int k) {
       PriorityQueue<Integer> minHeap = new PriorityQueue<>();
       for(int num :nums){
           minHeap.add(num);
           if(minHeap.size()>k){
               minHeap.poll();
           }
       }
    return minHeap.peek();
    }  
}

• 题目要求：给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
  算法的时间复杂度应该为 O(log (m+n)) 。
  
• 代码及思路
  • 分别用一个大根堆和一个小跟堆存储来存储两个数组中较小的一半元素和较大的一半元素
  • 大根堆存储元素数量大于等于小跟堆，每次将元素入队后需要对大根堆和小跟堆的大小进行调整
  • 最终的中位数就是两个队堆顶元素之和的一半或者是大根堆堆顶元素
  • 代码

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        PriorityQueue<Integer> minHeap=new PriorityQueue<>();
        PriorityQueue<Integer> maxHeap=new PriorityQueue<>((a,b)->b-a);
        for(int a:nums1){
            if(maxHeap.isEmpty()||a<maxHeap.peek()){
                maxHeap.offer(a);
            }else{
                minHeap.offer(a);
            }
            balance(maxHeap,minHeap);
        }
        for(int b:nums2){
            if(maxHeap.isEmpty()||b<maxHeap.peek()){
                maxHeap.offer(b);
            }else{
                minHeap.offer(b);
            }
            balanc(maxHeap,minHeap);
        }
        if(maxHeap.size()==minHeap.size())return (maxHeap.peek()+minHeap.peek())/2.0;
        return maxHeap.peek()/1.0;
    }
    private void balanc(PriorityQueue<Integer> maxHeap,PriorityQueue<Integer> minHeap){
        if(maxHeap.size()>minHeap.size()+1){
            minHeap.offer(maxHeap.poll());
        }else if(minHeap.size()>maxHeap.size()){
            maxHeap.offer(minHeap.poll());
        }
    }
}

• 题目要求：给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。
  
• 代码及思路
  • 使用hash和堆排序解决问题
  • 首先遍历数组统计每个元素出现的次数，然后根据每个元素的个数将其存储到一个大根堆中
  • 取出堆中的前k个元素，即为答案
  • 代码

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer,Integer> cache=new HashMap<>();
        for(int num:nums){
            cache.put(num,cache.getOrDefault(num,0)+1);
        }
        PriorityQueue<Integer> que=new PriorityQueue<>((a,b)->cache.get(b)-cache.get(a));
        for(int key:cache.keySet()){
            que.offer(key);
        }
        int[] res=new int[k];
        for(int i=0;i<k;i++){
            res[i]=que.poll();
        }
        return res;
    }
}