深入浅出Java算法：栈与队列处理类问题

V少年2025-04-15 11:20

深入浅出Java算法：栈与队列处理类问题

栈和队列是两种重要的线性数据结构，在算法问题中应用广泛。下面我将用通俗易懂的方式介绍常见的栈和队列处理问题及其解决方案。

一、栈篇

1. 有效的括号

问题：判断字符串中的括号是否有效匹配

java 复制代码 
public boolean isValid(String s) {
    Stack<Character> stack = new Stack<>();
    for (char c : s.toCharArray()) {
        if (c == '(' || c == '[' || c == '{') {
            stack.push(c);
        } else {
            if (stack.isEmpty()) return false;
            char top = stack.pop();
            if ((c == ')' && top != '(') || 
                (c == ']' && top != '[') || 
                (c == '}' && top != '{')) {
                return false;
            }
        }
    }
    return stack.isEmpty();
}

2. 最小栈

问题：设计一个支持push、pop、top操作，并能检索最小元素的栈

java 复制代码 
class MinStack {
    private Stack<Integer> stack;
    private Stack<Integer> minStack;

    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }
    
    public void push(int val) {
        stack.push(val);
        if (minStack.isEmpty() || val <= minStack.peek()) {
            minStack.push(val);
        }
    }
    
    public void pop() {
        if (stack.pop().equals(minStack.peek())) {
            minStack.pop();
        }
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

3. 逆波兰表达式求值

问题：根据逆波兰表示法（后缀表达式）求表达式的值

java 复制代码 
public int evalRPN(String[] tokens) {
    Stack<Integer> stack = new Stack<>();
    for (String token : tokens) {
        if ("+-*/".contains(token)) {
            int b = stack.pop();
            int a = stack.pop();
            switch (token) {
                case "+": stack.push(a + b); break;
                case "-": stack.push(a - b); break;
                case "*": stack.push(a * b); break;
                case "/": stack.push(a / b); break;
            }
        } else {
            stack.push(Integer.parseInt(token));
        }
    }
    return stack.pop();
}

4. 每日温度

问题：给定每日温度列表，返回需要等待多少天才能有更高温度的天数

java 复制代码 
public int[] dailyTemperatures(int[] temperatures) {
    Stack<Integer> stack = new Stack<>();
    int[] result = new int[temperatures.length];
    for (int i = 0; i < temperatures.length; i++) {
        while (!stack.isEmpty() && temperatures[i] > temperatures[stack.peek()]) {
            int prevIndex = stack.pop();
            result[prevIndex] = i - prevIndex;
        }
        stack.push(i);
    }
    return result;
}

二、队列篇

1. 用栈实现队列

问题：使用栈实现队列的push、pop、peek和empty操作

java 复制代码 
class MyQueue {
    private Stack<Integer> inStack;
    private 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 inStack.isEmpty() && outStack.isEmpty();
    }
}

2. 滑动窗口最大值

问题：给定数组和滑动窗口大小，返回每次窗口滑动时的最大值

java 复制代码 
public int[] maxSlidingWindow(int[] nums, int k) {
    if (nums == null || nums.length == 0) return new int[0];
    
    int[] result = new int[nums.length - k + 1];
    Deque<Integer> deque = new ArrayDeque<>();
    
    for (int i = 0; i < nums.length; i++) {
        // 移除不在窗口范围内的元素
        while (!deque.isEmpty() && deque.peekFirst() < i - k + 1) {
            deque.pollFirst();
        }
        
        // 移除比当前元素小的元素，保持队列递减
        while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
            deque.pollLast();
        }
        
        deque.offerLast(i);
        
        // 当窗口形成时记录最大值
        if (i >= k - 1) {
            result[i - k + 1] = nums[deque.peekFirst()];
        }
    }
    
    return result;
}

3. 设计循环队列

问题：设计一个循环队列实现

java 复制代码 
class MyCircularQueue {
    private int[] queue;
    private int head;
    private int tail;
    private int size;
    private int capacity;

    public MyCircularQueue(int k) {
        queue = new int[k];
        head = 0;
        tail = -1;
        size = 0;
        capacity = k;
    }
    
    public boolean enQueue(int value) {
        if (isFull()) return false;
        tail = (tail + 1) % capacity;
        queue[tail] = value;
        size++;
        return true;
    }
    
    public boolean deQueue() {
        if (isEmpty()) return false;
        head = (head + 1) % capacity;
        size--;
        return true;
    }
    
    public int Front() {
        return isEmpty() ? -1 : queue[head];
    }
    
    public int Rear() {
        return isEmpty() ? -1 : queue[tail];
    }
    
    public boolean isEmpty() {
        return size == 0;
    }
    
    public boolean isFull() {
        return size == capacity;
    }
}

三、栈与队列综合问题

1. 柱状图中最大的矩形

问题：在柱状图中找出能勾勒出的最大矩形的面积

java 复制代码 
public int largestRectangleArea(int[] heights) {
    Stack<Integer> stack = new Stack<>();
    int maxArea = 0;
    int i = 0;
    
    while (i <= heights.length) {
        int h = (i == heights.length) ? 0 : heights[i];
        if (stack.isEmpty() || h >= heights[stack.peek()]) {
            stack.push(i++);
        } else {
            int top = stack.pop();
            int width = stack.isEmpty() ? i : i - stack.peek() - 1;
            maxArea = Math.max(maxArea, heights[top] * width);
        }
    }
    
    return maxArea;
}

2. 用队列实现栈

问题：使用队列实现栈的push、pop、top和empty操作

java 复制代码 
class MyStack {
    private Queue<Integer> queue;

    public MyStack() {
        queue = new LinkedList<>();
    }
    
    public void push(int x) {
        queue.offer(x);
        int size = queue.size();
        // 将新元素前面的所有元素重新入队
        for (int i = 0; i < size - 1; i++) {
            queue.offer(queue.poll());
        }
    }
    
    public int pop() {
        return queue.poll();
    }
    
    public int top() {
        return queue.peek();
    }
    
    public boolean empty() {
        return queue.isEmpty();
    }
}

总结

栈和队列问题的解决技巧：

  1. 栈的典型应用：

    • 括号匹配问题
    • 表达式求值
    • 单调栈解决边界问题
    • 深度优先搜索(DFS)

  2. 队列的典型应用：

    • 广度优先搜索(BFS)
    • 滑动窗口问题
    • 任务调度

  3. 常用技巧：

    • 使用辅助栈/队列（如最小栈问题）
    • 双栈实现队列/双队列实现栈
    • 单调栈/单调队列解决极值问题
    • 循环队列的实现技巧

记住解决这类问题的关键：

  • 理解栈(LIFO)和队列(FIFO)的基本特性
  • 画图辅助理解操作过程
  • 考虑边界条件（空栈/队列、单个元素等）
  • 合理选择数据结构和算法

掌握这些基础问题的解法，能够帮助你更好地解决更复杂的算法问题！

相关推荐
顾林海33 分钟前
深度解析LinkedHashMap工作原理
android·java·面试
JasonYin35 分钟前
Git提交前缀
android
louisgeek1 小时前
Android 类加载机制
android
碎风,蹙颦1 小时前
Android开发过程中遇到的SELINUX权限问题
android·人工智能
HZW89702 小时前
鸿蒙应用开发—数据持久化之SQLite
android·前端·harmonyos
百锦再2 小时前
Android Studio 日志系统详解
android·java·ide·app·android studio·安卓·idea
fatiaozhang95272 小时前
晶晨线刷工具下载及易错点说明：Key文件配置错误／mac剩余数为0解决方法
android·电视盒子·魔百盒刷机
QING6186 小时前
详解：Kotlin 类的继承与方法重载
android·kotlin·app
QING6186 小时前
Kotlin 伴生对象(Companion Object)详解 —— 使用指南
android·kotlin·app
一一Null6 小时前
Android studio 动态布局
android·java·android studio
热门推荐
01我决定放弃搞 Java 了02RAG 实践- Ollama+RagFlow 部署本地知识库03DeepSeek各版本说明与优缺点分析04Scipy||第三章 线性代数 (scipy.linalg)05DeepSeek RAGFlow构建本地知识库系统06如何在WPS和Word/Excel中直接使用DeepSeek功能07汽车上的各种质量：整备质量、总质量、装载质量、簧上质量、簧下质量08从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑09本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程10C#/.NET/.NET Core技术前沿周刊 | 第 34 期（2025年4.7-4.13）