LeetCode--347--medium--TopKFrequentElements

summary:

min heap | override priority queue compare | time complexity O(NlgK)

package myapp.kit.leetcode.top100liked;

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;

/**
 * 347
 * medium
 * https://leetcode.com/problems/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.
 * It's guaranteed that the answer is unique, in other words the set of the top k frequent elements is unique.
 * You can return the answer in any order.
 *
 *
 * @author huangdingsheng
 * @version 1.0, 2020/5/8
 */
public class TopKFrequentElements {

    public int[] topKFrequent(int[] nums, int k) {
        if (nums == null || nums.length == 0) {
            return new int[0];
        }
        Map<Integer, Node> countMap = new HashMap<>();
        // List<Node> count = new ArrayList<>();
        Queue<Node> minHeap = new PriorityQueue<>(new Comparator<Node>() {
            @Override
            public int compare(Node o1, Node o2) {
                return o1.v - o2.v;
            }
        });
        for (int i = 0; i < nums.length; i++) {
            Node node = null;
            if (countMap.containsKey(nums[i])) {
                node = countMap.get(nums[i]);
                node.v = node.v + 1;
            } else {
                node = new Node(nums[i], 1);
                countMap.put(nums[i], node);
            }
        }

        for (Map.Entry<Integer, Node> entry : countMap.entrySet()) {
            if (minHeap.size() < k) {
                minHeap.add(entry.getValue());
            } else {
                if (minHeap.peek().v < entry.getValue().v) {
                    minHeap.poll();
                    minHeap.add(entry.getValue());
                }
            }
        }
        int[] result = new int[minHeap.size()];
        for (int i = 0; i < result.length; i++) {
            Node node = minHeap.poll();
            result[i] = node.k;
        }
        return result;
    }

    class Node {
        public Integer k;
        public Integer v;
        public Node(Integer k, Integer v) {
            this.k = k;
            this.v = v;
        }
    }

    public static void main(String[] args) {
        int[] nums = new int[] {1, 1, 1, 2, 2, 3};
        TopKFrequentElements process = new TopKFrequentElements();
        System.out.println(process.topKFrequent(nums, 2));
    }
}