239. 滑动窗口最大值
给定一个数组 nums,有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回滑动窗口中的最大值。
暴力方法,遍历一遍的过程中每次从窗口中再找到最大的数值,O(n × k)
单调队列方法,保持单调队列里单调递减,此时队列出口元素就是窗口里最大元素。
遍历数组: 从数组的第一个元素开始,逐个遍历每个元素。
a. 入队操作: 将当前元素与队尾元素比较,将小于当前元素的队尾元素出队,然后将当前元素入队。
b. 窗口最大值判断: 判断当前元素是否进入一个完整的滑动窗口。如果是,则获取当前滑动窗口的最大值。
c. 出队操作: 如果当前队列头部元素的下标不在当前滑动窗口内,将其出队,保持队列头部元素在当前滑动窗口内。
输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3,动画如下:
- 时间复杂度: O(n)
- 空间复杂度: O(k)
#include <stdio.h>
#include <stdlib.h>
// 定义单调队列节点
typedef struct {
int value; // 元素值
int index; // 元素下标
} MonotonicQueueNode;
// 定义单调队列结构
typedef struct {
MonotonicQueueNode *array; // 存储队列元素的数组
int capacity; // 数组容量
int size; // 当前队列大小
int front; // 队列头指针
int rear; // 队列尾指针
} MonotonicQueue;
// 初始化单调队列
void initMonotonicQueue(MonotonicQueue *queue, int capacity) {
queue->array = (MonotonicQueueNode *)malloc(sizeof(MonotonicQueueNode) * capacity);
queue->capacity = capacity;
queue->size = 0;
queue->front = 0;
queue->rear = -1;
}
// 队尾入队
void pushBack(MonotonicQueue *queue, int value, int index) {
while (queue->size > 0 && queue->array[queue->rear].value < value) {
queue->rear--;
queue->size--;
}
queue->rear++;
queue->array[queue->rear].value = value;
queue->array[queue->rear].index = index;
queue->size++;
}
// 队头出队
void popFront(MonotonicQueue *queue, int index) {
if (queue->size > 0 && queue->array[queue->front].index == index) {
queue->front++;
queue->size--;
}
}
// 获取队头元素
int front(MonotonicQueue *queue) {
return queue->array[queue->front].value;
}
// 求滑动窗口最大值
int *maxSlidingWindow(int *nums, int numsSize, int k, int *returnSize) {
if (nums == NULL || numsSize == 0 || k <= 0) {
*returnSize = 0;
return NULL;
}
// 结果数组
int *result = (int *)malloc(sizeof(int) * (numsSize - k + 1));
*returnSize = numsSize - k + 1;
// 初始化单调队列
MonotonicQueue queue;
initMonotonicQueue(&queue, numsSize);
// 遍历数组
for (int i = 0; i < numsSize; i++) {
// 入队
pushBack(&queue, nums[i], i);
// 判断窗口是否形成,形成了就获取窗口最大值
if (i >= k - 1) {
result[i - k + 1] = front(&queue);
// 出队
popFront(&queue, i - k + 1);
}
}
// 释放队列内存
free(queue.array);
return result;
}
java写法
//解法一
//自定义数组
class MyQueue {
Deque<Integer> deque = new LinkedList<>();
//弹出元素时,比较当前要弹出的数值是否等于队列出口的数值,如果相等则弹出
//同时判断队列当前是否为空
void poll(int val) {
if (!deque.isEmpty() && val == deque.peek()) {
deque.poll();
}
}
//添加元素时,如果要添加的元素大于入口处的元素,就将入口元素弹出
//保证队列元素单调递减
//比如此时队列元素3,1,2将要入队,比1大,所以1弹出,此时队列:3,2
void add(int val) {
while (!deque.isEmpty() && val > deque.getLast()) {
deque.removeLast();
}
deque.add(val);
}
//队列队顶元素始终为最大值
int peek() {
return deque.peek();
}
}
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
if (nums.length == 1) {
return nums;
}
int len = nums.length - k + 1;
//存放结果元素的数组
int[] res = new int[len];
int num = 0;
//自定义队列
MyQueue myQueue = new MyQueue();
//先将前k的元素放入队列
for (int i = 0; i < k; i++) {
myQueue.add(nums[i]);
}
res[num++] = myQueue.peek();
for (int i = k; i < nums.length; i++) {
//滑动窗口移除最前面的元素,移除是判断该元素是否放入队列
myQueue.poll(nums[i - k]);
//滑动窗口加入最后面的元素
myQueue.add(nums[i]);
//记录对应的最大值
res[num++] = myQueue.peek();
}
return res;
}
}
//解法二
//利用双端队列手动实现单调队列
/**
* 用一个单调队列来存储对应的下标,每当窗口滑动的时候,直接取队列的头部指针对应的值放入结果集即可
* 单调队列类似 (tail -->) 3 --> 2 --> 1 --> 0 (--> head) (右边为头结点,元素存的是下标)
*/
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
ArrayDeque<Integer> deque = new ArrayDeque<>();
int n = nums.length;
int[] res = new int[n - k + 1];
int idx = 0;
for(int i = 0; i < n; i++) {
// 根据题意,i为nums下标,是要在[i - k + 1, i] 中选到最大值,只需要保证两点
// 1.队列头结点需要在[i - k + 1, i]范围内,不符合则要弹出
while(!deque.isEmpty() && deque.peek() < i - k + 1){
deque.poll();
}
// 2.既然是单调,就要保证每次放进去的数字要比末尾的都大,否则也弹出
while(!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
deque.pollLast();
}
deque.offer(i);
// 因为单调,当i增长到符合第一个k范围的时候,每滑动一步都将队列头节点放入结果就行了
if(i >= k - 1){
res[idx++] = nums[deque.peek()];
}
}
return res;
}
}
347.前 K 个高频元素
给定一个非空的整数数组,返回其中出现频率前 k 高的元素。
堆是一棵完全二叉树,树中每个结点的值都不小于(或不大于)其左右孩子的值。 如果父亲结点是大于等于左右孩子就是大顶堆,小于等于左右孩子就是小顶堆。
要统计最大前k个元素,只有小顶堆每次将最小的元素弹出,最后小顶堆里积累的才是前k个最大元素,所以用小顶堆。
寻找前k个最大元素流程如图所示:
// 结构体定义,用于表示哈希表的节点
struct HashEntry {
int key;
int val;
UT_hash_handle hh; // uthash提供的哈希表处理结构
};
// 向哈希表中插入元素,统计频率
void hashAddItem(struct HashEntry **obj, int key) {
struct HashEntry *pEntry = NULL;
HASH_FIND_INT(*obj, &key, pEntry);
if (pEntry != NULL) {
// 如果元素已存在,增加频率
pEntry->val++;
} else {
// 如果元素不存在,创建新节点
pEntry = (struct HashEntry *)malloc(sizeof(struct HashEntry));
pEntry->key = key;
pEntry->val = 1;
HASH_ADD_INT(*obj, key, pEntry);
}
}
// 自定义比较函数,用于qsort排序
int compare(const void *a1, const void *b1) {
int *a = *(int **)a1;
int *b = *(int **)b1;
return b[1] - a[1]; // 按值降序排序
}
// 返回数组中前k个高频元素
int *topKFrequent(int *nums, int numsSize, int k, int *returnSize) {
// 哈希表初始化
struct HashEntry *hashTable = NULL;
// 统计元素频率并插入哈希表
for (int i = 0; i < numsSize; i++) {
hashAddItem(&hashTable, nums[i]);
}
// 将哈希表中的元素转移到数组 que 中
int count = HASH_COUNT(hashTable);
int **que = (int **)malloc(sizeof(int *) * count);
int n = 0;
struct HashEntry *s;
for (s = hashTable; s != NULL; s = s->hh.next) {
que[n] = (int *)malloc(sizeof(int) * 2);
que[n][0] = s->key;
que[n++][1] = s->val;
}
// 使用 qsort 对数组进行排序
qsort(que, count, sizeof(int *), compare);
// 选取前 k 个元素作为结果
int *result = (int *)malloc(sizeof(int) * k);
*returnSize = k;
for (int i = 0; i < k; i++) {
result[i] = que[i][0];
}
// 释放内存
for (int i = 0; i < count; i++) {
free(que[i]);
}
free(que);
HASH_CLEAR(hh, hashTable); // 释放哈希表内存
return result;
}
java写法
class Solution {
public int[] topKFrequent(int[] nums, int k) {
// 优先级队列,为了避免复杂 api 操作,pq 存储数组
// lambda 表达式设置优先级队列从大到小存储 o1 - o2 为从小到大,o2 - o1 反之
PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> o1[1] - o2[1]);
int[] res = new int[k]; // 答案数组为 k 个元素
Map<Integer, Integer> map = new HashMap<>(); // 记录元素出现次数
for(int num : nums) map.put(num, map.getOrDefault(num, 0) + 1);
for(var x : map.entrySet()) { // entrySet 获取 k-v Set 集合
// 将 kv 转化成数组
int[] tmp = new int[2];
tmp[0] = x.getKey();
tmp[1] = x.getValue();
pq.offer(tmp);
// 下面的代码是根据小根堆实现的,我只保留优先队列的最后的k个,只要超出了k我就将最小的弹出,剩余的k个就是答案
if(pq.size() > k) {
pq.poll();
}
}
for(int i = 0; i < k; i ++) {
res[i] = pq.poll()[0]; // 获取优先队列里的元素
}
return res;
}
}