LeetCode – Top K Frequent Elements (Java)

 

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

Java Solution 1 - Using HashMap and Heap

Time is O(n*log(k)).

class Pair{
    int num;
    int count;
    public Pair(int num, int count){
        this.num=num;
        this.count=count;
    }
}
 
public class Solution {
    public List<Integer> topKFrequent(int[] nums, int k) {
        //count the frequency for each element
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        for(int num: nums){
            if(map.containsKey(num)){
                map.put(num, map.get(num)+1);
            }else{
                map.put(num, 1);
            }
        }
 
        // create a min heap
        PriorityQueue<Pair> queue = new PriorityQueue<Pair>(new Comparator<Pair>(){
            public int compare(Pair a, Pair b){
                return a.count-b.count;
            }
        });
 
        //maintain a heap of size k. 
        for(Map.Entry<Integer, Integer> entry: map.entrySet()){
            Pair p = new Pair(entry.getKey(), entry.getValue());
            queue.offer(p);
            if(queue.size()>k){
                queue.poll();
            }
        }
 
        //get all elements from the heap
        List<Integer> result = new ArrayList<Integer>();
        while(queue.size()>0){
            result.add(queue.poll().num);
        }
        //reverse the order
        Collections.reverse(result);
 
        return result;
    }
}

Java Solution 2 - Bucket Sort

Time is O(n).

public List<Integer> topKFrequent(int[] nums, int k) {
    //count the frequency for each element
    HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
    for(int num: nums){
        if(map.containsKey(num)){
            map.put(num, map.get(num)+1);
        }else{
            map.put(num, 1);
        }
    }
 
    //get the max frequency
    int max = 0;
    for(Map.Entry<Integer, Integer> entry: map.entrySet()){
        max = Math.max(max, entry.getValue());
    }
 
    //initialize an array of ArrayList. index is frequency, value is list of numbers
    ArrayList<Integer>[] arr = (ArrayList<Integer>[]) new ArrayList[max+1];
    for(int i=1; i<=max; i++){
        arr[i]=new ArrayList<Integer>();
    }
 
    for(Map.Entry<Integer, Integer> entry: map.entrySet()){
        int count = entry.getValue();
        int number = entry.getKey();
        arr[count].add(number);
    }
 
    List<Integer> result = new ArrayList<Integer>();
 
    //add most frequent numbers to result
    for(int j=max; j>=1; j--){
        if(arr[j].size()>0){
            for(int a: arr[j]){
                result.add(a);
            }
        }
 
        if(result.size()==k)
            break;
    }
 
    return result;
}

Java Solution 3 - A Regular Counter (Deprecated)

We can solve this problem by using a regular counter, and then sort the counter by value.

public class Solution {
    public List<Integer> topKFrequent(int[] nums, int k) {
        List<Integer> result = new ArrayList<Integer>();
 
        HashMap<Integer, Integer> counter = new HashMap<Integer, Integer>();
 
        for(int i: nums){
            if(counter.containsKey(i)){
                counter.put(i, counter.get(i)+1);
            }else{
                counter.put(i, 1);
            }    
        }
 
        TreeMap<Integer, Integer> sortedMap = new TreeMap<Integer, Integer>(new ValueComparator(counter));
        sortedMap.putAll(counter);
 
        int i=0;
        for(Map.Entry<Integer, Integer> entry: sortedMap.entrySet()){
            result.add(entry.getKey());
            i++;
            if(i==k)
                break;
        }
 
        return result;
    }
}
 
class ValueComparator implements Comparator<Integer>{
    HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
 
    public ValueComparator(HashMap<Integer, Integer> m){
        map.putAll(m);
    }
 
    public int compare(Integer i1, Integer i2){
        int diff = map.get(i2)-map.get(i1);
 
        if(diff==0){
            return 1;
        }else{
            return diff;
        }
    }
}

Related posts:

  1. LeetCode – Majority Element II (Java)
  2. LeetCode – Largest Divisible Subset (Java)
  3. LeetCode – 4Sum (Java)
  4. LeetCode – Summary Ranges (Java)
Category >> Algorithms  
If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example: 
<pre><code> 
String foo = "bar";
</code></pre>

  1. Sudhakar R on 2016-5-12

    Second solution i think the code to populate result should look like this.

    for(int j=max; j>=k-1; j–){
    if(count[j].size()>0){
    for(int a: count[j]){
    result.add(a);
    }
    }
    }

  2. Ankit Shah on 2016-12-28

    Treemap code can be as concise as this:


    Map sortedMap = new TreeMap(new Comparator() {
    public int compare(Integer o1, Integer o2) {
    int diff = map.get(o2) - map.get(o1);
    return diff == 0 ? 1 : diff;
    }
    });
    sortedMap.putAll(counter);

  3. Longqi Zhang on 2017-2-27

    Java Solution 2 – Bucket Sort has bug.
    Try this array to test:

    int a[] = {1, 2, 4, 2, 2, 5, 1, 4, 2, 1, 4, 2};
    int k=2;

    The code below:

    if (result.size() == k) {
    break;
    }

    should be changed to:

    if (result.size() >= k) {
    break;
    }

Leave a comment

CAPTCHA

*