Leetcode347-前k个高频元素

最新推荐文章于 2024-09-12 13:19:42 发布

番茄炒蛋233

最新推荐文章于 2024-09-12 13:19:42 发布

阅读量96

点赞数 1

分类专栏：算法与数据结构文章标签：算法数据结构 leetcode

本文链接：https://blog.csdn.net/qq_43869106/article/details/131295630

版权

算法与数据结构专栏收录该内容

6 篇文章 3 订阅

订阅专栏

文章介绍了如何使用堆和快速选择算法来解决找到数组中出现频率前k的元素的问题。首先通过HashMap统计元素频率，然后利用小顶堆或快速选择算法进行处理。堆的方法是维护一个小顶堆，保证堆顶始终是频率高的元素；而快速选择算法则是基于快速排序的一种优化，用于寻找集合中的k个最大元素。文章提供了两种方法的Java实现代码。

摘要由CSDN通过智能技术生成

这题是一个比较经典的题，可以用堆或者快速选择算法去做，是一个复习堆和快排算法的好题，故记录一下。

题目描述

思路分析

这个题的思路还是很自然的，首先我们需要用一个HashMap去统计nums数组中出现的数以及出现频率，然后从这个HashMap中选择前k个出现频率高的元素返回。

从一个集合中返回前k个出现频率高的元素，比较常见的是用堆和快速选择算法去做。

1. 基于堆的解法

我们可以维护一个小顶堆，然后遍历HashMap：

如果堆中的元素个数小于k，直接把当前元素插入堆中
如果堆的元素个数等于 k，则检查堆顶与当前元素出现频率的大小。如果堆顶更大舍弃当前值，反之弹出堆顶，并将当前值插入堆中

这样维护该小顶堆就能得到集合中出现频率前k高的元素，因为小的都被舍弃了，大的插入了堆中。

2. 基于快速选择算法的解法

快速选择算法是基于快速排序算法的一种解决TOPK问题的算法。

leetcode官方题解中解释这个算法很详细，我就直接搬过来吧。

代码

1. 堆

class Solution {
    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<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;
    }
}

用堆写还是比较简单的，只要会使用PriorityQueue就行

2. 快速选择算法

class Solution {
    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));
            }
        }
    }
}