代码随想录 day13

题一：滑动窗口的最大值

题目链接： 滑动窗口的最大值
解题思路： 给定宽度的滑动窗口，从头到尾按这个窗口的长度遍历这个数组，并求出每次的最大元素，最后以数组的形式返回。其实用暴力解法挺容易的，窗口每移动一次就做一次排序操作，取出最大的那个元素然后加到res数组中，就以快排来说，整个算法的时间复杂度是O(n* nlogn)，有没有时间复杂度更小的算法呢，分析一下，时间主要用在了排序上，可以对这个操作进行优化不？答案是可以的，滑动窗口滑动的这个过程就是一个出队入队的过程，这里就用到了队列，没必要每一次都要放入三个元素，只放入可能成为窗口最大元素的值就可以了。这里设定一个case：

  1 3 -1 -3 5 3 2 1

指定窗口宽度为3。
初始化窗口，照正常情况下 1 3 -1都应该被push进窗口。但是1比它后面的3要小，且1在后边窗口的移动过程中需要被pop出去的，所以这里1可以不用放进来，然后再选出最大元素3，push进res数组。

窗口 [3,1]
res [3]

窗口往后移动 此时包含的元素有 3 -1 -3，窗口里现在只有俩个元素，且都比-3要大，直接push即可,并把最大值放进res。

窗口 [3,-1,-3]
res[3,3]

再次向后移动，此时窗口经过的元素有-1 -3 5,窗口现有元素有 3 -1 -3，因为5比里边的所有元素都要大，且之后的遍历有5在的话就用不着这些元素了，所以什么 3 -1 -3 全都出来，5进去，此时窗口最大元素就是5。

窗口 [5]
res[3,3,5]

继续向后移动，窗口经过的元素有-3 5 3，3可能后面成为最大元素，3进来，在这里我们可以得出这样一个结论，只要窗口里原有的元素比当前要新加入的元素小的话全部都要滚出去，否则就是该进的进，该淘汰的淘汰。

窗口 [5,3]
res[3,4,5,5]

继续向后移动，窗口经过的元素有 5 3 2，2理所应当可以进来

窗口 [5,3,2]
res[3,4,5,5,5]

继续向后移动，窗口经过的元素有 3 2 1，5此时不在窗口里面了，1应该到窗口里边来。

窗口 [3,2,1]
res[3,4,5,5,5,3]

至此遍历结束，返回res。
从上边针对新方法可以总结出以下结论：
整个过程大致分为五个阶段，遍历、移动、入队、出队、取出最大元素，其中出队入队需要挑出来说明，最大元素需要保持在对头，如果出现了新入队的元素比原来窗口里的元素都要大的话，则这前面的元素都要去掉。出队的话每次都是出当前对头元素也就是当前窗口里的最大元素。
解题代码：

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number[]}
 */
class MonoQueue {
    constructor() {
        this.queue = [];
    }
    enqueue(value) {
        let back = this.queue[this.queue.length - 1];
        while (back !== undefined && back < value) {
            this.queue.pop();
            back = this.queue[this.queue.length - 1];
        }
        this.queue.push(value)
    }
    dequeue(value) {
        let front = this.front();
        if (front === value) {
            this.queue.shift();
        }
    }
    front() {
        return this.queue[0];
    }
}
var maxSlidingWindow = function (nums, k) {
    let helperQueue = new MonoQueue();
    let i = 0, j = 0;
    let resArr = [];
    while (j < k) {
        helperQueue.enqueue(nums[j++]);
    }
    resArr.push(helperQueue.front());
    while (j < nums.length) {
        helperQueue.enqueue(nums[j]);
        helperQueue.dequeue(nums[i]);
        resArr.push(helperQueue.front());
        i++;
        j++;
    }
    return resArr;
};

题二：前k个高频元素

题目链接：前k个高频元素
解题思路： 给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。其实解题很容易，无非就是把一个数出现多少次都记录下来，然后再排序，取出前k个就行，这里采用map作为数据结构，针对排序的优化，这里可以借助使用小顶堆。
解题代码：

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number[]}
 */
//  js没有堆 需要自己构造
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]);
    }
}
var topKFrequent = function (nums, k) {
    const map = new Map();

    for (const num of nums) {
        map.set(num, (map.get(num) || 0) + 1);
    }

    // 创建小顶堆
    const heap = new Heap((a, b) => a[1] - b[1]);

    // entry 是一个长度为2的数组，0位置存储key，1位置存储value
    for (const entry of map.entries()) {
        heap.push(entry);

        if (heap.size() > k) {
            heap.pop();
        }
    }

    // return heap.queue.map(e => e[0]);

    const res = [];

    for (let i = heap.size() - 1; i >= 0; i--) {
        res[i] = heap.pop()[0];
    }

    return res;
};