LeetCode_347

题意以及限制条件

1. 题目：

2. 限制条件：
   

想到的所有可能解法

• Ways_1——HashMap、Map.Entry、QuickSelect

  0. 平均 时间复杂度——O(n)；空间复杂度——O(n)。

• Ways_2——基于PriorityQueue的小顶堆

  0. 时间复杂度——O(n*logk)；空间复杂度——O(n)。

• Ways_3——HashMap、Map.Entry、TreeMap

  0. 时间复杂度——O(n*logn)；空间复杂度——O(n)。

对应的代码

• Ways_1

class Solution {
    public int[] topKFrequent(int[] nums, int k) {  
        Map<Integer, Integer> hashmap = new HashMap<Integer, Integer>();
        for (int num : nums) {
            hashmap.put(num, hashmap.getOrDefault(num, 0) + 1);
        }
        List<int[]> values = new ArrayList<int[]>();
        for (Map.Entry<Integer, Integer> entry : hashmap.entrySet()) {
            int num = entry.getKey(), count = entry.getValue();
            values.add(new int[] {num, count});
        }
        int len = values.size();
        quickSelect(values, 0, len - 1,  len - k);
        int[] res = new int[k];
        for (int i = 0; i < k; ++i) {
            res[i] = values.get(--len)[0];
        }
        return res;
        
    }

    private static void quickSelect(List<int[]> values, int begin, int end, int k) {
        if (end <= begin) return;
        int pivot = partition(values, begin, end);
        if (k < pivot) {
            quickSelect(values, begin, pivot - 1, k);
        } else if (k > pivot) {
            quickSelect(values, pivot + 1, end, k);
        } else {
            return;
        }
    }

    private static int partition(List<int[]> values, int begin, int end) {
        int pivot = end, counter = begin;
        for (int i = begin; i < end; ++i) {
            if (values.get(i)[1] < values.get(pivot)[1]) {
                if (i != counter) {
                    Collections.swap(values, i, counter++);
                } else {
                    ++counter;
                }
            }
        }
        Collections.swap(values, pivot, counter);
        return counter;
    }
}

• Ways_2

class Solution {
    public int[] topKFrequent(int[] nums, int k) {  

        Map<Integer, Integer> hashmap = new HashMap<Integer, Integer>();
        for (int num : nums) {
            hashmap.put(num, hashmap.getOrDefault(num, 0) + 1);
        }
        PriorityQueue<Integer> q = new PriorityQueue<Integer>(new Comparator<Integer>(){
            public int compare(Integer k1, Integer k2) {
                return hashmap.get(k1) - hashmap.get(k2);
            }
        });

        for (int key : hashmap.keySet()) {
            if (q.size() < k) {
                q.offer(key);
            } else if(hashmap.get(key) > hashmap.get(q.peek())) {
                q.poll();
                q.offer(key);
            }
        }

        int[] res = new int[k];
        for (int j = k - 1; j >= 0; --j) {
            res[j] = q.poll();
        }
        return res;

    }
}

• Ways_3

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> hashmap = new HashMap<Integer, Integer>();
        for (int num : nums) {
            hashmap.put(num, hashmap.getOrDefault(num, 0) + 1);
        }

        TreeMap<Integer, List<Integer>> freqMap = new TreeMap<Integer, List<Integer>>();
        for (int key : hashmap.keySet()) {
            int freq = hashmap.get(key);
            if (!freqMap.containsKey(freq)) {
                freqMap.put(freq, new LinkedList<Integer>());
            }
            freqMap.get(freq).add(key);
        }

        List<Integer> resIn = new ArrayList<Integer>();
        while (resIn.size() < k) {
            Map.Entry<Integer, List<Integer>> entry = freqMap.pollLastEntry();
            resIn.addAll(entry.getValue());
        }

        int[] res = new int[k];
        for (int i = k - 1; i >= 0; --i) {
            res[i] = resIn.get(i);
        }

        return res;
    }
}

测试样例