239. 滑动窗口最大值
给定一个数组 nums,有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。
返回滑动窗口中的最大值。
var nums = [1, 3, -1, -3, 5, 3, 6, 7]
var k = 3
var maxSlidingWindow = function (nums, k) {
var res = []
var queue = []
for (var i = 0; i < nums.length; i++) {
// 如果队列不为空,且队尾元素小于当前元素,那么队尾元素出队
while (queue.length > 0 && nums[queue[queue.length - 1]] <= nums[i]) {
// 队尾元素出队
queue.pop()
}
// 当前元素入队
queue.push(i)
// 如果队头元素已经不在滑动窗口内,那么队头元素出队
if (queue[0] <= i - k) {
queue.shift()
}
// 如果滑动窗口形成,那么队头元素就是滑动窗口的最大值
if (i >= k - 1) {
// 将滑动窗口的最大值加入到结果数组中
res.push(nums[queue[0]])
}
}
return res
}
console.log(maxSlidingWindow(nums, k))
/**
* @param {number[]} nums
* @param {number} k
* @return {number[]}
*/
var maxSlidingWindow = function (nums, k) {
// 单调队列
class MonoQueue {
// 队列
queue;
// 构造函数
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];
}
}
// 边界条件判断
let helperQueue = new MonoQueue();
let i = 0, j = 0;
let resArr = [];
// 先将前 k 个元素入队
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;
};
347.前 K 个高频元素
给定一个非空的整数数组,返回其中出现频率前 k 高的元素。
示例 1:
输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]
示例 2:
输入: nums = [1], k = 1
输出: [1]
var nums = [1,1,1,2,2,3]
var k = 2
var topKFrequent = function(nums, k) {
let map = new Map()
for (let i = 0; i < nums.length; i++) {
if (map.has(nums[i])) {
map.set(nums[i], map.get(nums[i]) + 1)
} else {
map.set(nums[i], 1)
}
}
let arr = Array.from(map)
arr.sort((a, b) => b[1] - a[1])
return arr.slice(0, k).map(item => item[0])
// arr.slice(0, k)的意思是返回一个新数组,新数组的每一项是arr[0]到arr[k-1]
//map(item => item[0])的意思是返回一个新数组,新数组的每一项是item[0]
}
console.log(topKFrequent(nums, k))
// // 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]);
}
}
const 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;
};