Leetcode:347. 前 K 个高频元素(java)

题目描述:

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案

示例1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

示例2:

输入: nums = [1], k = 1
输出: [1]

我这里使用的是基于快速排序的思想，假设我们有数组[2,2,2,1,1,1,1,3,3,4]，将其转换为，键为数，值为出现的次数，map[{2,3},{1,4},{3,2},{4,1}]，在将每个键值对放入list<int[]>,list每个元素为[key,value],为list[{2,3},{1,4},{3,2},{4,1}]。然后开始基于快速排序思想，以第一个为基准，比较list每个元素的value，就是要根据出现次数排序，将所有大于第一个的数放到基准前面，所有小于的放到基准后面，就是list[{1,4},{2,3},{3,2},{4,1}]

第一轮结束后，这里就出现三种情况，我们假设index为基准位置，start为开始位置，end为结束位置:

1.如果前面的大于基准的数的个数大于k个，那么前k个频率最高的数，就在前面，我们将范围缩小，从开始位置到基准位置-1，继续下一轮快排。

2.如果前面的大于基准的数的个数小于k个，那么就代表，基准左边的不够，就要去右边再找k-(index-start+1)个，递归。

3.剩下的就是刚刚好的情况，就不用递归了。

代码如下:

public class Solution {

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

        Map<Integer, Integer> map = new HashMap<>();
        //转成map集合，键表示每个数，值表示出现的次数
        for (int num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        List<int[]> values = new ArrayList<>();
        Set<Integer> keys = map.keySet();
        //将map集合转换为list,每个list为int[]{key,value}
        for (Integer key : keys) {
            values.add(new int[]{key, map.get(key)});
        }
        int[] res = new int[k];
        //开始快速排序
        qsort(values, 0, values.size() - 1, res, 0, k);
        return res;
    }

    public void qsort(List<int[]> values, int start, int end, int[] res, int resIndex, int k) {
        
        int tem = values.get(start)[1];
        int index = start;
        //大的放左边，小的放右边
        for (int i = start + 1; i <= end; i++) {
            if (values.get(i)[1] >= tem) {
                Collections.swap(values, index+1, i);
                index++;
            }
        }
        Collections.swap(values, start, index);
        //如果前面的大于基准的数的个数大于k个
        if (k <= index - start) {
            //继续向左缩小范围找
            qsort(values, start, index - 1, res, resIndex, k);
        } else {
            //否则，先将左边的放入结果集
            for (int i = start; i <= index; i++) {
                res[resIndex++] = values.get(i)[0];
            }
            //判断是否还少，如果少了就去右边找
            if (k > index - start + 1) {
                qsort(values, index + 1, end, res, resIndex, k - (index - start + 1));
            }
        }
    }
}

时间复杂度：O(N^2)

空间复杂度：O(N)