【LeetCode】347. 前 K 个高频元素（中等）——代码随想录算法训练营Day13

题目链接：347. 前 K 个高频元素

题目描述

给你一个整数数组?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?个高频元素的集合是唯一的

进阶：你所设计算法的时间复杂度?必须?优于?O(n log n)?，其中?n?是数组大小。

文章讲解：代码随想录

视频讲解：优先级队列正式登场！大顶堆、小顶堆该怎么用？| LeetCode：347.前 K 个高频元素_哔哩哔哩_bilibili

题解1：小顶堆

思路：使用 Map 作为哈希表存储数组中每个元素的次数，再用小顶堆排序得到前 k 个高频元素。

class Heap {
    constructor(compareFn) {
        this.compareFn = compareFn;
        this.queue = [];
    }

    // 添加
    push(item) {
        // 推入元素
        this.queue.push(item);

        // 上浮
        let index = this.size() - 1; // 记录推入元素下标
        let parent = Math.floor((index - 1) / 2); // 记录父节点下标

        while (parent >= 0 && this.compare(parent, index) > 0) { // 注意compare参数顺序
            [this.queue[index], this.queue[parent]] = [this.queue[parent], this.queue[index]];

            // 更新下标
            index = parent;
            parent = Math.floor((index - 1) / 2);
        }
    }

    // 获取堆顶元素并移除
    pop() {
        // 堆顶元素
        const out = this.queue[0];

        // 移除堆顶元素 填入最后一个元素
        this.queue[0] = this.queue.pop();

        // 下沉
        let index = 0; // 记录下沉元素下标
        let left = 1; // left 是左子节点下标 left + 1 则是右子节点下标
        let searchChild = this.compare(left, left + 1) > 0 ? left + 1 : left;

        while (searchChild !== undefined && this.compare(index, searchChild) > 0) { // 注意compare参数顺序
            [this.queue[index], this.queue[searchChild]] = [this.queue[searchChild], this.queue[index]];

            // 更新下标
            index = searchChild;
            left = 2 * index + 1;
            searchChild = this.compare(left, left + 1) > 0 ? left + 1 : left;
        }

        return out;
    }

    size() {
        return this.queue.length;
    }

    // 使用传入的 compareFn 比较两个位置的元素
    compare(index1, index2) {
        // 处理下标越界问题
        if (this.queue[index1] === undefined) return 1;
        if (this.queue[index2] === undefined) return -1;

        return this.compareFn(this.queue[index1], this.queue[index2]);
    }

}

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number[]}
 */
var topKFrequent = function(nums, k) {
    const heap = new Heap((a, b) => a.count - b.count);
    const map = {};

    // 使用哈希表存储每个元素出现次数
    nums.forEach(n => {
        map[n] = map[n] ? map[n] + 1 : 1;
    });

    // 使用小顶堆排序的到前 k 高的元素
    for (let n in map) {
        heap.push({ num: n, count: map[n] });
        if (heap.size() > k) {
            heap.pop();
        }
    }
    return heap.queue.map(item => item.num);
};

分析：时间复杂度为 O(nlogk)，空间复杂度为 O(n)。

收获

堆是一种完全二叉树，里面的元素已经按顺序排好序了，在对部分元素排序时可以考虑使用堆。