leetcode topkfrequentelements

import java.util.*;

public class  {
  
   * Top K Frequent Elements
   * Given a non-empty array of integers, return the k most frequent elements.
   *
   * Example 1:
   *
   * Input: nums = [1,1,1,2,2,3], k = 2
   * Output: [1,2]
   * Example 2:
   *
   * Input: nums = [1], k = 1
   * Output: [1]
   * Note:
   *
   * You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
   * Your algorithm's time complexity must be better than O(n log n), where n is the array's size.
   */
  public List<Integer> topKFrequent(int[] nums, int k) {
    HashMap<Integer, Integer> frequency = new HashMap<>();
    PriorityQueue<int[]> res = new PriorityQueue<int[]>((a, b)-> a[1] - b[1]);
    for (int i: nums){
      if (!frequency.containsKey(i)){
        int count = frequency.get(i);
        frequency.replace(i, count + 1);
      }
      else {
        frequency.put(i, 1);
      }
    }
    for (int key: frequency.keySet()){
      int f = frequency.get(key);
      if (res.size()!= k){
        res.offer(new int[]{key, f});
      }
      else {
        int[] t = res.poll();
        if (t[1] > f){
          res.remove();
          res.offer(new int[]{key, f});
        }
      }
    }

    List<Integer> r = new LinkedList<>();
    for (int f: frequency.keySet()){
      r.add(f);
    }
    return r;
  }


  public List<Integer> topKFrequentII(int[] nums, int k) {
    HashMap<Integer, Integer> frequency = new HashMap<>();
    for (int i: nums) {
      if (!frequency.containsKey(i)) {
        frequency.put(i, 0);
      }
      frequency.put(i, frequency.get(i)+1);
    }

    List<Integer>[] bucket = new List[nums.length];

    for (int key: frequency.keySet()) {
      int f = frequency.get(key);
      if (bucket[f] == null) {
        bucket[f] = new ArrayList<>();
      }
      bucket[f].add(key);
    }

    List<Integer> ans = new ArrayList<>();

    for (int i=nums.length-1; i>=0 && k>0; i--) {
      if (bucket[i] != null) {
        for (int num: bucket[i]){
          ans.add(num);
        }
        k -= bucket[i].size();
      }
    }
    return ans;
  }

}