LeetCode前 K 个高频元素（堆）

Posted 2023-04-05 小锦鲤yaw

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了LeetCode前 K 个高频元素（堆）相关的知识，希望对你有一定的参考价值。

1.题目要求：

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

2.解题思路：

代码展示：

1.题目要求：

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

示例 1:

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

示例 2:

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

提示：

1 <= nums.length <= 105
k 的取值范围是 [1, 数组中不相同的元素的个数]
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的

2.解题思路：

创建一个哈希表，用其存放数组中出现的元素以及每个元素出现的次数

        //用哈希表存储出现的元素，和出现的次数
        Map<Integer,Integer> map = new HashMap<>();
        for (int i:nums) 
            if(map.containsKey(i))
                map.put(i,map.get(i) + 1);
            else 
                map.put(i,1);

先创建一个类numOfTimes , 其中有两个属性，一个key值，一个k值出现的次数

//创建一个类，其中两个属性，一个k值，一个k值出现的次数
class numOfTimes

    int key;
    int times;

    public numOfTimes(int key, int times) 
        this.key = key;
        this.times = times;

写一个类numsSortWayOfTimes继承Comparator方法接口，重写compare方法（对numOfTimes对象进行排序比较的方式---key值出现的次数times的大小）

class numsSortWayOfTimes implements Comparator<numOfTimes> 
    @Override
    public int compare(numOfTimes o1, numOfTimes o2) 
        return o1.times - o2.times;

将map内的key值按照出现次数进行比大小

建立一个优先级队列大小为k,存储（元素与出现次数的）numOfTimes的对象

遍历队列后就会将出现次数最多的元素对象留在了堆中

        //将map内的key值按照出现次数进行比大小
        //建立一个优先级队列大小为k,存储（元素与出现次数的）numOfTimes的对象
        //遍历队列后就会将出现次数最多的元素留在了堆中
        Queue<numOfTimes> queue = new PriorityQueue<>(new numsSortWayOfTimes());
        //遍历map，将出现次数最高的前k个numOfTimes对象保存在堆中
        for (Map.Entry<Integer,Integer> entry:map.entrySet()) 
            queue.offer(new numOfTimes(entry.getKey(),entry.getValue()));
            if(queue.size() > k)
                queue.poll();

此时队列中存放的就是出现次数最多的元素对象
遍历队列将对象的key值保存在数组中，返回该数组即可

        //此时队列中存放的就是出现次数最多的元素
        //遍历队列将key值保存在数组中
        int[] res = new int[k];
        for(int i = 0; i < k; i++)
            res[i] = queue.poll().key;
        
        return res;

代码展示：

import java.util.*;


//创建一个类，其中两个属性，一个k值，一个k值出现的次数
class numOfTimes

    int key;
    int times;

    public numOfTimes(int key, int times) 
        this.key = key;
        this.times = times;
    


//对numOfTimes进行排序比较的方式，（出现次数）
//继承Comparator接口重写compare方法
class numsSortWayOfTimes implements Comparator<numOfTimes> 
    @Override
    public int compare(numOfTimes o1, numOfTimes o2) 
        return o1.times - o2.times;
    


public class Leetcode_347 
    //给你一个整数数组 nums 和一个整数 k ，
    // 请你返回其中出现频率前 k 高的元素。
    // 你可以按 任意顺序 返回答案。
//    输入: nums = [1,1,1,2,2,3], k = 2
//    输出: [1,2]
    public int[] topKFrequent(int[] nums, int k) 
        //用哈希表存储出现的元素，和出现的次数
        Map<Integer,Integer> map = new HashMap<>();
        for (int i:nums) 
            if(map.containsKey(i))
                map.put(i,map.get(i) + 1);
            else 
                map.put(i,1);
            
        

        //将map内的key值按照出现次数进行比大小
        //建立一个优先级队列大小为k,存储（元素与出现次数的）numOfTimes的对象
        //遍历队列后就会将出现次数最多的元素留在了堆中
        Queue<numOfTimes> queue = new PriorityQueue<>(new numsSortWayOfTimes());
        //遍历map，将出现次数最高的前k个numOfTimes对象保存在堆中
        for (Map.Entry<Integer,Integer> entry:map.entrySet()) 
            queue.offer(new numOfTimes(entry.getKey(),entry.getValue()));
            if(queue.size() > k)
                queue.poll();
            

        
        //此时队列中存放的就是出现次数最多的元素
        //遍历队列将key值保存在数组中
        int[] res = new int[k];
        for(int i = 0; i < k; i++)
            res[i] = queue.poll().key;
        
        return res;

LeetCode刷题（130）～前 K 个高频元素最小堆｜快速排列难点！

题目描述

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

示例 1:

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

示例 2:

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

提示：

你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
你的算法的时间复杂度必须优于 O(n log n) , n 是数组的大小。
题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。
你可以按任意顺序返回答案。

解答 By 海轰

提交代码

vector<int> topKFrequent(vector<int>& nums, int k) 
        unordered_map<int,int> m;
        for(int num:nums)
        ++m[num];
        vector<int> a;
        for(auto i:m)
        a.push_back(i.second);
        sort(a.begin(),a.end());
        vector<int> b;
         for(int i=a.size()-1;i>=(a.size()-k)&&i>=0;--i)
         
             b.push_back(a[i]);
         
        sort(b.begin(),b.end());
        vector<int> ans;
        for(auto i:m)
        
            if(i.second>=b[0])
            ans.push_back(i.first);
        
        return ans;

运行结果

LeetCode刷题（130）～前

解答

Demo（最小堆）

static bool cmp(pair<int, int>& m, pair<int, int>& n) 
        return m.second > n.second;
    

    vector<int> topKFrequent(vector<int>& nums, int k) 
        unordered_map<int, int> occurrences;
        for (auto& v : nums) 
            occurrences[v]++;
        

        // pair 的第一个元素代表数组的值，第二个元素代表了该值出现的次数
        priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(&cmp)> q(cmp);
        for (auto& [num, count] : occurrences) 
            if (q.size() == k) 
                if (q.top().second < count) 
                    q.pop();
                    q.emplace(num, count);
                
             else 
                q.emplace(num, count);
            
        
        vector<int> ret;
        while (!q.empty()) 
            ret.emplace_back(q.top().first);
            q.pop();
        
        return ret;

运行结果

LeetCode刷题（130）～前

Demo（快速排列）

void qsort(vector<pair<int, int>>& v, int start, int end, vector<int>& ret, int k) 
        int picked = rand() % (end - start + 1) + start;
        swap(v[picked], v[start]);

        int pivot = v[start].second;
        int index = start;
        for (int i = start + 1; i <= end; i++) 
            if (v[i].second >= pivot) 
                swap(v[index + 1], v[i]);
                index++;
            
        
        swap(v[start], v[index]);

        if (k <= index - start) 
            qsort(v, start, index - 1, ret, k);
         else 
            for (int i = start; i <= index; i++) 
                ret.push_back(v[i].first);
            
            if (k > index - start + 1) 
                qsort(v, index + 1, end, ret, k - (index - start + 1));
            
        
    

    vector<int> topKFrequent(vector<int>& nums, int k) 
        unordered_map<int, int> occurrences;
        for (auto& v: nums) 
            occurrences[v]++;
        

        vector<pair<int, int>> values;
        for (auto& kv: occurrences) 
            values.push_back(kv);
        
        vector<int> ret;
        qsort(values, 0, values.size() - 1, ret, k);
        return ret;