LeetCode每日一题（20200907）

原题地址：

思考过程：

先遍历一遍数组，然后用map存数据，key表示数字，value表示数字的个数。

然后对Map.Entry进行排序，再返回前k位的key即可。

 

代码实现：

    public int[] topKFrequent3(int[] nums, int k) {
        int[] ans = new int[k];
        Map<Integer, Integer> map = new HashMap<>();
        for (int i : nums) {
            if (!map.containsKey(i)) {
                map.put(i, 1);
            } else {
                int v = map.get(i);
                map.put(i, v + 1);

            }
        }
        List<Map.Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet());
        list.sort(new Comparator<Map.Entry<Integer, Integer>>() {
            @Override
            public int compare(Map.Entry<Integer, Integer> o1, 
                                Map.Entry<Integer, Integer> o2) {
                return o2.getValue() - o1.getValue();
            }
        });
        for (int i = 0; i < list.size(); i++) {
            ans[i] = list.get(i).getKey();
        }
        return ans;
    }

 

算法复杂度分析：

不考虑list.sort的复杂度，时间复杂度可以表示为O(n)。

 

其他实现代码：

//1
static class Compettt {
        public int i;
        public int num;

        public Compettt(int ii, int numm) {
            i = ii;
            num = numm;
        }
    }

    public int[] topKFrequent2(int[] nums, int k) {
        Map<Integer, Compettt> map = new HashMap<>();
        for (int n = 0; n < nums.length; n++) {
            int i = nums[n];
            if (!map.containsKey(i)) {
                map.put(i, new Compettt(i, 1));
            } else {
                map.put(i, new Compettt(i, 1 + map.get(i).num));
            }
        }
        int[] ans = new int[k];
        List<Compettt> list = new ArrayList<>();
        for (Map.Entry<Integer, Compettt> entry : map.entrySet()) {
            list.add(entry.getValue());
        }
        Collections.sort(list, new Comparator<Compettt>() {
            @Override
            public int compare(Compettt o1, Compettt o2) {
                return o2.num - o1.num;
            }
        });
        for (int i = 0; i < k; i++) {
            ans[i] = list.get(i).i;
        }
        return ans;
    }


//2
 public int[] topKFrequent(int[] nums, int k) {
        int[] ans = new int[k];
        Map<Integer, Integer> map = new HashMap<>();
        List<Integer> list = new ArrayList<>();
        for (int i : nums) {
            if (!map.containsKey(i)) {
                map.put(i, 1);
                list.add(1);
            } else {
                int v = map.get(i);
                map.put(i, v + 1);
                for (int in = 0; in < list.size(); in++) {
                    if (list.get(in) == v) {
                        list.remove(in);
                        break;
                    }
                }
                list.add(v + 1);
            }
        }
        list.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        for (int i : list) {
            for (Map.Entry<Integer, Integer> e : map.entrySet()) {
                if (e.getValue() == i) {
                    ans[--k] = e.getKey();
                    if (k <= 0) {
                        return ans;
                    }
                    map.remove(e.getKey());
                    break;
                }
            }
        }
        return ans;
    }

 

查看官方解法：

方法一使用了hash+堆的解法。