347 Top K Frequent Elements

Problem:

Given a non-empty array of integers, return the k most frequent elements.

For example, Given [1,1,1,2,2,3] and k = 2, return [1,2].

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.

Solutions:

public class Solution {
    public List<Integer> topKFrequent(int[] nums, int k) {
        HashMap<Integer, Integer> count = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; i ++) {
            if (!count.containsKey(nums[i])) {
                count.put(nums[i], 0);
            }
            count.put(nums[i], count.get(nums[i]) + 1);
        }
        HashMap<Integer, Queue<Integer>> reverse = new HashMap<Integer, Queue<Integer>>();
        PriorityQueue<Integer> app = new PriorityQueue<Integer>(k, Collections.reverseOrder());
        for (Integer i:count.keySet()) {
            int val = count.get(i);
            app.add(val);
            if (!reverse.containsKey(val)){
                reverse.put(val, new LinkedList());
            }
            reverse.get(val).add(i);
        }
        List<Integer> result = new LinkedList<Integer>();
        for (int i = 0; i < k; i ++) {
            int val = app.poll();
            result.add(reverse.get(val).poll());
        }
        return result;
    }
}

public class Solution {
    private class Count {
        public int num;
        public int count;
        public Count(int num, int count) {
            this.num = num;
            this.count = count;
        }
    }
    private class CountComparator implements Comparator<Count> {
        public int compare(Count c1, Count c2)  {
            return c1.count - c2.count;
        }
    }
    public List<Integer> topKFrequent(int[] nums, int k) {
        HashMap<Integer, Integer> count = new HashMap<Integer, Integer>();
        for (int i = 0; i < nums.length; i ++) {
            if (!count.containsKey(nums[i])) {
                count.put(nums[i], 0);
            }
            count.put(nums[i], count.get(nums[i]) + 1);
        }
        PriorityQueue<Count> app = new PriorityQueue<Count>(k + 1, new CountComparator());
        for (Integer i:count.keySet()) {
            int val = count.get(i);
            app.add(new Count(i, val));
            if (app.size() > k) {
                app.poll();
            }
        }
        List<Integer> result = new LinkedList<Integer>();
        for (int i = 0; i < k; i ++) {
            int num = app.poll().num;
            result.add(0, num);
        }
        return result;
    }
}

public class Solution {
    public List<Integer> topKFrequent(int[] nums, int k) {
        HashMap<Integer, Integer> count = new HashMap<Integer, Integer>();
        int max = 0;
        for (int i = 0; i < nums.length; i ++) {
            if (!count.containsKey(nums[i])) {
                count.put(nums[i], 0);
            }
            int c = count.get(nums[i]) + 1;
            max = Math.max(max, c);
            count.put(nums[i], c);
        }
        LinkedList<Integer>[] bucket = (LinkedList<Integer>[]) new LinkedList[max+1];
        for (Integer i:count.keySet()) {
            int val = count.get(i);
            if (bucket[val] == null) {
                bucket[val] = new LinkedList<Integer>();
            }
            bucket[val].add(i);
        }
        List<Integer> result = new LinkedList<Integer>();
        for (int i = 0; i < k; i ++) {
            while(bucket[max] == null || bucket[max].size() == 0) {
                max --;
            }
            result.add(bucket[max].poll());
        }
        return result;
    }
}