【算法之栈与队列I】leetcode239. 滑动窗口最大值

已于 2023-06-30 10:04:54 修改
阅读量184 收藏
点赞数
分类专栏： 算法 文章标签： 算法 java 开发语言
于 2023-06-25 09:40:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42985872/article/details/131371070
版权

232.用栈实现队列

力扣题目链接

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

  • 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
  • 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。
输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

解决思路

  1. 使用输入栈和输出栈。将数据存放到输入栈，再放到输出栈。

Java实现

class MyQueue {

    Stack<Integer> inStack;

    Stack<Integer> outStack;

    public MyQueue() {
        inStack = new Stack<>();
        outStack = new Stack<>();
    }

    public void push(int x) {
        inStack.push(x);
    }

    public int pop() {
        if (outStack.isEmpty()) {
            while (!inStack.isEmpty()) {
                outStack.push(inStack.pop());
            }
        }
        return outStack.pop();

    }

    public int peek() {
        if (outStack.isEmpty()) {
            while (!inStack.isEmpty()) {
                outStack.push(inStack.pop());
            }
        }
        return outStack.peek();
    }

    public boolean empty() {
        return outStack.isEmpty() && inStack.isEmpty();
    }
}

225. 用队列实现栈

力扣题目链接

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素。
  • int top() 返回栈顶元素。
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

解决思路

  1. 把新增的元素始终放在队列开头，队列添加元素默认是放在队列末尾的。
  2. 使用双队列，一个队列用作备份，一个队列用于获取元素。备份队列放入新元素，再放入旧元素，切换队列。
  3. 使用单队列，先把元素放在最后，再把以前存入的元素重新放入队列中。

java实现

使用两个队列

class MyStack {

    private Queue<Integer> queue1;

    private Queue<Integer> queue2;

    public MyStack() {
        queue1 = new LinkedList<>();
        queue2 = new LinkedList<>();
    }

    public void push(int x) {
        queue2.offer(x);
        while (!queue1.isEmpty()) {
            queue2.offer(queue1.poll());
        }
        Queue<Integer> tmp = queue1;
        queue1 = queue2;
        queue2 = tmp;

    }

    public int pop() {
        return queue1.poll();
    }

    public int top() {
        return queue1.peek();
    }

    public boolean empty() {
        return queue1.isEmpty();
    }
}

使用单队列

class MyStack {
    Queue<Integer> queue;

    /** Initialize your data structure here. */
    public MyStack() {
        queue = new LinkedList<Integer>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        int n = queue.size();
        queue.offer(x);
        for (int i = 0; i < n; i++) {
            queue.offer(queue.poll());
        }
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        return queue.poll();
    }
    
    /** Get the top element. */
    public int top() {
        return queue.peek();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue.isEmpty();
    }
}

20. 有效的括号

力扣题目链接

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。
输入：s = "()"
输出：true

解决思路

  1. 计算长度
  2. 使用hashMap，匹配字符串。
  3. 左边的字符直接入栈，右边的字符需要判断栈是否为空或者栈顶元素是左边字符。

Java实现

class Solution_LC20 {

    public boolean isValid(String s) {
        if (s.length() % 2 == 1) {
            return false;
        }
        Map<Character, Character> pairs = new HashMap<Character, Character>() {{
            put(')', '(');
            put(']', '[');
            put('}', '{');
        }};
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            if (pairs.containsKey(s.charAt(i))) {
                if (stack.isEmpty() || pairs.get(s.charAt(i)) != stack.peek()) {
                    return false;
                }
                stack.pop();
            } else {
                stack.push(s.charAt(i));
            }
        }
        if (stack.isEmpty()) {
            return true;
        }
        return false;
    }
}

1047. 删除字符串中的所有相邻重复项

力扣题目链接

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

输入："abbaca"
输出："ca"
解释：
例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。

解决思路

  1. 使用栈，匹配字符相等，则消除。

Java实现

class Solution_LC1047 {
    public String removeDuplicates(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (stack.isEmpty() || stack.peek() != ch) {
                stack.push(ch);
            } else {
                stack.pop();
            }
        }
        StringBuilder sb = new StringBuilder();
        while (!stack.isEmpty()) {
            sb.append(stack.pop());
        }
        return sb.reverse().toString();
    }
}

150. 逆波兰表达式求值

力扣题目链接

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

  • 有效的算符为 '+'、'-'、'*' 和 '/' 。
  • 每个操作数（运算对象）都可以是一个整数或者另一个表达式。
  • 两个整数之间的除法总是 向零截断 。
  • 表达式中不含除零运算。
  • 输入是一个根据逆波兰表示法表示的算术表达式。
  • 答案及所有中间计算结果可以用 32 位 整数表示。
输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

解决思路

  1. 使用栈记录需要计算的字符。

Java实现

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < tokens.length; i++) {
            if (tokens[i].equals("+")) {
                stack.push(stack.pop() + stack.pop());
            } else if (tokens[i].equals("-")) {
                stack.push(-stack.pop() + stack.pop());
            } else if (tokens[i].equals("*")) {
                stack.push(stack.pop() * stack.pop());
            } else if (tokens[i].equals("/")) {
                int tmp = stack.pop();
                stack.push(stack.pop() / tmp);
            } else {
                stack.push(Integer.valueOf(tokens[i]));
            }
        }
        return stack.pop();
    }
}

239. 滑动窗口最大值

力扣题目链接

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

解决思路

  1. 使用优先队列。优先队列要明确左右两端。右端是索引i，左边是索引i-k+1。
  2. 优先队列大顶端，比较元素大小。new PriorityQueue<>((a, b) -> b[1] - a[1]);
  3. 使用单调队列。一旦遇到比当前栈顶元素大的都弹出，小的都压进来。
  4. 使用双端队列。维护队列，保持队列元素在[i - k + 1, i]范围内
  5. 双端队列，压入元素，将比自己小的元素推出，始终维持在范围内最大的元素在最前面。

Java实现

使用优先队列

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((a, b) -> b[1] - a[1]);
        int len = nums.length;
        int m = len - k + 1;
        int[] ans = new int[m];
        for (int i = 0; i < len; i++) {
            priorityQueue.offer(new int[]{i, nums[i]});
            if (i >= k - 1) {
                int left = i - k + 1;
                while (priorityQueue.peek()[0] <= i - k) {
                    priorityQueue.poll();
                }
                ans[left] = priorityQueue.peek()[1];
            }
        }
        return ans;
    }
}

使用双端队列

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        Deque<Integer> deque = new LinkedList<>();
        int len = nums.length;
        int[] res = new int[len - k + 1];
        int idx = 0;
        for (int i = 0; i < len; i++) {
            if (!deque.isEmpty() && deque.peek() < i - k + 1) {
                deque.poll();
            }
            while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
                deque.pollLast();
            }
            deque.offer(i);
            if (i >= k - 1) {
                res[idx++] = nums[deque.peek()];
            }
        }
        return res;
    }
}

347.前 K 个高频元素

力扣题目链接

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

解决思路

  1. 计算数组中元素的个数
  2. 挨个将元素和元素个数加入到优先队列
  3. 挨个从优先队列中取出元素

Java实现

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
        }
        PriorityQueue<int[]> priorityQueue = new PriorityQueue<>((a, b) -> b[1] - a[1]);
        for (Integer key : map.keySet()) {
            priorityQueue.add(new int[]{key, map.get(key)});
        }
        int[] res = new int[k];
        for (int i = 0; i < k; i++) {
            res[i] = priorityQueue.poll()[0];
        }
        return res;
    }
}

在这里插入图片描述

秋装什么
关注
专栏目录
Leetcode 239. 滑动窗口最大值
qq_44653420的博客
07-17 443
Leetcode 239. 滑动窗口最大值
LeetCode 239. 滑动窗口最大值 单调队列详解 Java
Lentr0py的博客
08-14 805
滑动窗口最大值问题通过使用单调队列来维护窗口内的最大值，以O(n)的时间复杂度解决了问题。这种方法不仅简单易行，而且非常高效，是处理类似滑动窗口问题的经典策略。
Leetcode 239.滑动窗口最大值
weixin_44852067的博客
08-28 229
Leetcode 239.滑动窗口最大值
LeetCode 239. 滑动窗口最大值 | C++语言版
weixin_45992021的博客
03-13 427
给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。 返回 滑动窗口中的最大值 。
leetcode239. 滑动窗口最大值(思路+详解)
qq_48508278的博客
01-11 652
一：题目 二:思路 1.这个题不能用优先队列，虽然我们可以通过优先队列得到最大值，但是我们在移动 窗口的时候,便不可以正常的删除元素了 2.虽然不能用优先对列，但是我们依然希望可以得到队首的元素的时候是最大值，同时还不影响移动窗口的时候 pop()元素了,这就引出了单调队列 3.单调队列中的元素是从大到小（注意不是全部的元素放入单调队列中） 那就和优先队列没啥区别了。 4.单调队列中 push(value)元素的时候，value值不能比出口的元素大，直到找到一个出口的元素 比vaule值大，OK,将其pu
力扣（LeetCode） 239.滑动窗口最大值（java）
Cnc2014的博客
04-26 487
给你一个整数数组 nums，有一个大小为k的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k个数字。滑动窗口每次只向右移动一位。 返回 滑动窗口中的最大值 。
LeetCode——239.滑动窗口最大值
玄昌盛不会编程
07-18 272
leetcode滑动窗口最大值
leetcode239. 滑动窗口最大值 单调栈 单调队列
ResumeProject的博客
03-29 256
还有一点是，滑动窗口需要将right-length+1位置的值弹出(从存储结构中更新)双端队列（deque:double_end_queue）可以从队尾弹出元素。插入时先判断，如果比当前的小，就popback。细节：单调队列是允许相同值的元素存在的。插入元素时类似一个单调栈。
LeetCode 239.滑动窗口最大值
m0_56728976的博客
05-20 315
主页有其他数据结构内容（持续更新中） 难度：Hard 代码： Solution1:比较容易想到优先队列（效率较低） class Solution { public: vector<int> maxSlidingWindow(vector<int>& nums, int k) { priority_queue<pair<int, int>> pq; vector<int> res; fo
php-leetcode题解之滑动窗口最大值.zip
06-09
在LeetCode上，滑动窗口最大值的题目有多种变形，例如可以求解滑动窗口的平均值、最小值等，但基本思路都是利用滑动窗口和合适的数据结构来高效地处理问题。熟练掌握这类问题对于提高编程能力和面试表现都非常有帮助...
LeetCode 239.滑动窗口最大值（C++）单调队列
伍粟的博客
01-24 368
给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。 返回滑动窗口中的最大值。 前言 对于每个滑动窗口，我们可以使用 O(k) 的时间遍历其中的每一个元素，找出其中的最大值。对于长度为 n 的数组 nums 而言，窗口的数量为 n−k+1，因此该算法的时间复杂度为O((n−k+1)k)=O(n k)，会超出时间限制，因此我们需要进行一些优化。 我们可以想到，对于两个相邻（只差了一个位置）的滑动窗口
代码随想录算法训练营第13天 | LeetCode 239. 滑动窗口最大值，347.前 K 个高频元素，总结
a976903676的博客
11-08 222
LeetCode 239. 滑动窗口最大值，347.前 K 个高频元素，总结
滑动窗口最大值---leetcode 239题（详解详解）
m0_50046535的博客
05-11 1765
对于小白的建议，这个题的最好解法肯定是用队列，我看网上将单调队列看到云里雾里，建议跟着题动手推，理解的更快一点 解法1： 常规双指针法 思路：定义两个指针，指在窗口的两端，然后遍历窗口内部的元素找到最大值，输出。然后两个指针一起向后移动重复执行上述步骤。 class Solution { public: int calcMax(int left,int right,vector<int>& nums) { int max = nums[left]; .
力扣 16.最接近的三数之和
qq_51352130的博客
09-16 352
设 s=nums[i]+nums[j]+nums[k]，为了判断 s 是不是与 target 最近的数，我们还需要用一个变量 minDiff 维护 ∣s−target∣ 的最小值。分类讨论：如果 s=target，那么答案就是 s，直接返回 s。如果 s>target，那么如果 s−target<minDiff，说明找到了一个与 target 更近的数，更新 minDiff 为 s−target，更新答案为 s。然后和三数之和一样，把 k 减一。
代码随想录算法训练营Day7
最新发布
lynyzy的博客
09-18 443
双指针
拥塞控制算法为何失效，网络为何难以测量？
Netfilter
09-14 7260
所以你知道实验室仿真的宇宙第一算法为啥拉了吧，也就不用再问为什么部署了 bbr 却还不如 cubic 了吧，如果你还希望研发一个精准的，普适的端到端算法，我劝你改行去卖皮鞋，至少还有很多经理市场。这和上一篇说的测量系统容量的方法并不矛盾，因为对于网络传输系统而言，系统是动态变化的，在流量部署到系统上并开始传输时，没有全局视图，就不能指望全局公平，留下的 gap 是固有的，没法靠算法弥补。，超级经典的一篇论文，我推荐过不止一次，因此我本文不谈异构问题，说点别的，比如拓扑。对，就是要砸，因为我不干了。
【例题】lanqiao4425 咖啡馆订单系统
m0_73676887的博客
09-17 282
样例输入样例输出3 2样例说明输入的数组为：【3，1，2】增量序列为：【2，1】当增量 h=2：对于每一个索引 i，我们会将数组元素 arr[i] 与 arr[i−h] 进行比较，并进行可能的交换。当增量 h=1：这就是一个普通的插入排序。总结：总共进行了 3 次比较，2 次交换。
双指针算法专题（2）
我要学编程的博客
09-16 948
LeetCode刷题：有效三角形的个数、查找总价格为目标值的两个商品（两数之和）、三数之和、四数之和
单调队列：数据结构与滑动窗口最大值解题
单调队列的一个经典应用是在处理滑动窗口的最大值问题，例如LeetCode上的第239题《滑动窗口最大值》。在这个问题中，我们需要找出数组中每个大小为k的连续子数组的最大值。使用单调队列，我们可以在O(n)的时间复杂度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值