【算法与数据结构】单调队列：高效解决滑动窗口问题

最新推荐文章于 2025-03-14 22:13:38 发布

小俊学长

最新推荐文章于 2025-03-14 22:13:38 发布

阅读量418

点赞数 3

文章标签：算法数据结构

本文链接：https://blog.youkuaiyun.com/hong161688/article/details/145882346

版权

【算法与数据结构】单调队列：高效解决滑动窗口问题

单调队列是一种特殊的队列结构，它能够保证队列内的元素始终保持单调递增或单调递减的顺序。这种数据结构在处理滑动窗口问题时表现出色，能够高效地维护窗口内的最大值或最小值。本文将详细介绍单调队列的原理、实现方法以及其在滑动窗口问题中的应用。

一、单调队列的基本原理

单调队列的核心思想是利用队列的先进先出（FIFO）特性，同时保证队列内的元素单调有序。通过这种方式，可以在常数时间内获取队列的最大值或最小值。

1. 单调递增队列

单调递增队列保证队列内的元素从队头到队尾单调递增。这种队列通常用于维护滑动窗口的最小值。

2. 单调递减队列

单调递减队列保证队列内的元素从队头到队尾单调递减。这种队列通常用于维护滑动窗口的最大值。

二、单调队列的实现

单调队列的实现基于双端队列（deque），支持从队头和队尾进行插入和删除操作。以下是单调队列的基本操作：

1. 插入元素

在插入元素时，需要保证队列的单调性。对于单调递增队列，插入元素时需要删除队尾所有比当前元素大的元素；对于单调递减队列，插入元素时需要删除队尾所有比当前元素小的元素。

2. 删除元素

删除元素时，需要检查队头元素是否在当前滑动窗口内。如果队头元素已经超出窗口范围，则需要将其删除。

3. 获取最大值或最小值

对于单调递增队列，队头元素是最小值；对于单调递减队列，队头元素是最大值。

三、单调队列的实现代码

以下是单调队列的实现代码，包括单调递增队列和单调递减队列的实现。

1. 单调递增队列（维护最小值）

#include <iostream>
#include <deque>
#include <vector>
using namespace std;

vector<int> slidingWindowMin(const vector<int>& nums, int k) {
    deque<int> dq; // 单调递增队列
    vector<int> result;

    for (int i = 0; i < nums.size(); ++i) {
        // 删除队尾所有比当前元素大的元素
        while (!dq.empty() && nums[dq.back()] > nums[i]) {
            dq.pop_back();
        }
        dq.push_back(i);

        // 删除超出窗口范围的元素
        if (dq.front() <= i - k) {
            dq.pop_front();
        }

        // 当窗口形成后，记录最小值
        if (i >= k - 1) {
            result.push_back(nums[dq.front()]);
        }
    }

    return result;
}

int main() {
    vector<int> nums = {1, 3, -1, -3, 5, 3, 6, 7};
    int k = 3;
    vector<int> result = slidingWindowMin(nums, k);
    for (int num : result) {
        cout << num << " ";
    }
    return 0;
}

2. 单调递减队列（维护最大值）

#include <iostream>
#include <deque>
#include <vector>
using namespace std;

vector<int> slidingWindowMax(const vector<int>& nums, int k) {
    deque<int> dq; // 单调递减队列
    vector<int> result;

    for (int i = 0; i < nums.size(); ++i) {
        // 删除队尾所有比当前元素小的元素
        while (!dq.empty() && nums[dq.back()] < nums[i]) {
            dq.pop_back();
        }
        dq.push_back(i);

        // 删除超出窗口范围的元素
        if (dq.front() <= i - k) {
            dq.pop_front();
        }

        // 当窗口形成后，记录最大值
        if (i >= k - 1) {
            result.push_back(nums[dq.front()]);
        }
    }

    return result;
}

int main() {
    vector<int> nums = {1, 3, -1, -3, 5, 3, 6, 7};
    int k = 3;
    vector<int> result = slidingWindowMax(nums, k);
    for (int num : result) {
        cout << num << " ";
    }
    return 0;
}

四、单调队列的应用场景

单调队列在处理滑动窗口问题时表现出色，能够高效地维护窗口内的最大值或最小值。以下是一些常见的应用场景：

1. 滑动窗口最大值

给定一个整数数组 nums 和一个滑动窗口的大小 k，返回滑动窗口内的最大值。

vector<int> maxSlidingWindow(vector<int>& nums, int k) {
    deque<int> dq;
    vector<int> result;

    for (int i = 0; i < nums.size(); ++i) {
        while (!dq.empty() && nums[dq.back()] < nums[i]) {
            dq.pop_back();
        }
        dq.push_back(i);

        if (dq.front() <= i - k) {
            dq.pop_front();
        }

        if (i >= k - 1) {
            result.push_back(nums[dq.front()]);
        }
    }

    return result;
}

2. 滑动窗口最小值

给定一个整数数组 nums 和一个滑动窗口的大小 k，返回滑动窗口内的最小值。

vector<int> minSlidingWindow(vector<int>& nums, int k) {
    deque<int> dq;
    vector<int> result;

    for (int i = 0; i < nums.size(); ++i) {
        while (!dq.empty() && nums[dq.back()] > nums[i]) {
            dq.pop_back();
        }
        dq.push_back(i);

        if (dq.front() <= i - k) {
            dq.pop_front();
        }

        if (i >= k - 1) {
            result.push_back(nums[dq.front()]);
        }
    }

    return result;
}

3. 最长递增子数组

给定一个整数数组 nums，返回最长递增子数组的长度。

int longestIncreasingSubarray(vector<int>& nums) {
    deque<int> dq;
    int maxLength = 0;

    for (int i = 0; i < nums.size(); ++i) {
        while (!dq.empty() && nums[dq.back()] >= nums[i]) {
            dq.pop_back();
        }
        dq.push_back(i);

        maxLength = max(maxLength, i - dq.front() + 1);
    }

    return maxLength;
}