前 K 个高频元素

1. 题目描述

给定一个非空的整数数组，返回其中出现频率前k高的元素。
示例 1:

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

示例 2:

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

2. 题解

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

	// int[] 的第一个元素代表数组的值，第二个元素代表了该值出现的次数
	// PriorityQueue是优先队列。这里次数少的在前面，用peek或者poll方法会获取到最前面的值。
	PriorityQueue<int[]> queue = new PriorityQueue<int[]>(new Comparator<int[]>() {
		public int compare(int[] m, int[] n) {
			return m[1] - n[1];
		}
	});
	for (Map.Entry<Integer, Integer> entry : occurrences.entrySet()) {
		int num = entry.getKey(), count = entry.getValue();
		if (queue.size() == k) {
			if (queue.peek()[1] < count) {
				queue.poll();
				queue.offer(new int[]{num, count});
			}
		} else {
			queue.offer(new int[]{num, count});
		}
	}
	int[] ret = new int[k];
	for (int i = 0; i < k; ++i) {
		ret[i] = queue.poll()[0];
	}
	return ret;
}

当queue.size() == k时，表示队列中已经有k个元素，但不一定是数组中前k高的元素。这时从队列中获取的值如果小于当前遍历的元素，则将其从队列中移除，并将当前遍历的元素添加到队列中。
注意到这里用的是优先队列PriorityQueue，该队列中最小的值在队列的最前面。

基于快速排序

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

	List<int[]> values = new ArrayList<int[]>();
	for (Map.Entry<Integer, Integer> entry : occurrences.entrySet()) {
		int num = entry.getKey(), count = entry.getValue();
		values.add(new int[]{num, count});
	}
	int[] ret = new int[k];
	qsort(values, 0, values.size() - 1, ret, 0, k);
	return ret;
}

public void qsort(List<int[]> values, int start, int end, int[] ret, int retIndex, int k) {
	int picked = (int) (Math.random() * (end - start + 1)) + start;
	Collections.swap(values, picked, start);
	
	int pivot = values.get(start)[1];
	int index = start;
	for (int i = start + 1; i <= end; i++) {
		if (values.get(i)[1] >= pivot) {
			Collections.swap(values, index + 1, i);
			index++;
		}
	}
	Collections.swap(values, start, index);

	if (k <= index - start) {
		qsort(values, start, index - 1, ret, retIndex, k);
	} else {
		for (int i = start; i <= index; i++) {
			ret[retIndex++] = values.get(i)[0];
		}
		if (k > index - start + 1) {
			qsort(values, index + 1, end, ret, retIndex, k - (index - start + 1));
		}
	}
}

快速排序的过程：从数组中选一个基准值，小于等于该基准值的元素放到左边，大于该基准值的元素放到右边。基准值两边的子数组递归调用该过程。
这里的基准值为pivot。这里的index是集合中比基准值大的数当中最右边的那个数的索引，因为一开始就把基准值交换到start位置上，最后交换start和index位置上的元素，这样就实现了基准值左边的数都小于等于它，而右边的数都大于它。
接下来找前k高的元素，这要看基准值的位置。前k高的元素可能都在基准值的左边，又有可能有一部分在基准值的右边。

参考：

• 前 K 个高频元素 - 前 K 个高频元素 - 力扣（LeetCode）