算法通关村—栈的经典算法解析

最新推荐文章于 2024-11-09 21:51:15 发布

叼着奶瓶逛酒吧

最新推荐文章于 2024-11-09 21:51:15 发布

阅读量67

点赞数

分类专栏：编程导航算法通关村文章标签：算法 java

本文链接：https://blog.csdn.net/weixin_44253799/article/details/131920441

版权

编程导航算法通关村专栏收录该内容

18 篇文章 0 订阅

订阅专栏

1.括号匹配问题

LeetCode20. 给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

示例1：
输入：s = "()[]{}"
输出：true

    public boolean isVaild(String s) {
        if (s.length() < 1) {
            return false;
        }

        Map<Character, Character> smap = new HashMap<>();
        smap.put('(', ')');
        smap.put('{', '}');
        smap.put('[', ']');
        Stack<Character> stack = new Stack<>();

        for (int i = 0; i < s.length(); i++) {
            char item = s.charAt(i);
            if (smap.containsKey(item)) {
                stack.push(item);
            } else {
                if (stack.isEmpty()) {
                    return false;
                } else {
                    Character pop = stack.pop();
                    Character character = smap.get(pop);
                    if (character == null || character != item) {
                        return false;
                    }
                }
            }
        }
        return stack.isEmpty();
    }

拓展

Leetcode22:数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例1
输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]
  
示例2
输入：n = 1
输出：["()"]

    Stack<Character> stack = new Stack<>();
    List<String> res = new ArrayList<>();

    public List<String> generateParenthesis(int n) {
        dfsTrack(0, 0, n);
        return res;
    }

    private void dfsTrack(int openN, int closeN, int n) {
        if (openN == closeN && closeN == n) {
            StringBuilder temp = new StringBuilder();
            for (Character character : stack) {
                temp.append(character);
            }
            res.add(temp.toString());
        }
        if (openN < n) {
            stack.push('(');
            dfsTrack(openN + 1, closeN, n);
            stack.pop();
        }
        if (closeN < openN) {
            stack.push(')');
            dfsTrack(openN, closeN + 1, n);
            stack.pop();
        }
    }


    public static void main(String[] args) {
        String s = "(]{}";
        StackDemo stackDemo = new StackDemo();
        System.out.println(stackDemo.isVaild(s));

        List<String> list = stackDemo.generateParenthesis(3);
        list.forEach(item -> {
            System.out.println(item + ":" + stackDemo.isVaild(item));
        });
    }


((())):true
(()()):true
(())():true
()(()):true
()()():true

2.最小栈

LeetCode 155，设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
实现 MinStack 类:

MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。
  
输入：
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]

输出：
[null,null,null,null,-3,null,0,-2]

解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.getMin();   --> 返回 -2.

本题的关键在于理解getMin()到底表示什么，可以看一个例子上面的示例画成示意图如下：

在这里插入图片描述

这里的关键是理解对应的Min栈内，中间元素为什么是-2，理解了本题就非常简单。

题目要求在常数时间内获得栈中的最小值，因此不能在 getMin() 的时候再去计算最小值，最好应该在 push 或者 pop 的时候就已经计算好

了当前栈中的最小值。

对于栈来说，如果一个元素 a 在入栈时，栈里有其它的元素 b, c, d，那么无论这个栈在之后经历了什么操作，只要 a 在栈中，b, c, d 就一

定在栈中，因为在 a 被弹出之前，b, c, d 不会被弹出。

因此，在操作过程中的任意一个时刻，只要栈顶的元素是 a，那么我们就可以确定栈里面现在的元素一定是 a, b, c, d。

那么，我们可以在每个元素 a 入栈时把当前栈的最小值 m 存储起来。在这之后无论何时，如果栈顶元素是 a，我们就可以直接返回存储的

最小值 m。

按照上面的思路，我们只需要设计一个数据结构，使得每个元素 a 与其相应的最小值 m 时刻保持一一对应。因此我们可以使用一个辅助

栈，与元素栈同步插入与删除，用于存储与每个元素对应的最小值。

当一个元素要入栈时，我们取当前辅助栈的栈顶存储的最小值，与当前元素比较得出最小值，将这个最小值插入辅助栈中；
当一个元素要出栈时，我们把辅助栈的栈顶元素也一并弹出；
在任意一个时刻，栈内元素的最小值就存储在辅助栈的栈顶元素中。

class MinStack {
    Deque<Integer> xStack;
    Deque<Integer> minStack;

    public MinStack() {
        xStack = new LinkedList<Integer>();
        minStack = new LinkedList<Integer>();
        minStack.push(Integer.MAX_VALUE);
    }
    
    public void push(int x) {
        xStack.push(x);
        minStack.push(Math.min(minStack.peek(), x));
    }
    
    public void pop() {
        xStack.pop();
        minStack.pop();
    }
    
    public int top() {
        return xStack.peek();
    }
    
    public int getMin() {
        return minStack.peek();
    }
}

3.最大栈

LeetCode 716.设计一个最大栈数据结构，既支持栈操作，又支持查找栈中最大元素。
实现 MaxStack 类:

MaxStack() 初始化栈对象
void push(int x) 将元素 x 压入栈中。
int pop() 移除栈顶元素并返回这个元素。
int top() 返回栈顶元素，无需移除。
int peekMax() 检索并返回栈中最大元素，无需移除。
int popMax() 检索并返回栈中最大元素，并将其移除。
    如果有多个最大元素，只要移除 最靠近栈顶 的那个。
  
输入
["MaxStack", "push", "push", "push", "top", "popMax", "top", "peekMax", "pop", "top"]
[[], [5], [1], [5], [], [], [], [], [], []]
输出
[null, null, null, null, 5, 5, 1, 5, 1, 5]

解释
MaxStack stk = new MaxStack();
stk.push(5);   // [5] - 5 既是栈顶元素，也是最大元素
stk.push(1);   // [5, 1] - 栈顶元素是 1，最大元素是 5
stk.push(5);   // [5, 1, 5] - 5 既是栈顶元素，也是最大元素
stk.top();     // 返回 5，[5, 1, 5] - 栈没有改变
stk.popMax();  // 返回 5，[5, 1] - 栈发生改变，栈顶元素不再是最大元素
stk.top();     // 返回 1，[5, 1] - 栈没有改变
stk.peekMax(); // 返回 5，[5, 1] - 栈没有改变
stk.pop();     // 返回 1，[5] - 此操作后，5 既是栈顶元素，也是最大元素
stk.top();     // 返回 5，[5] - 栈没有改变

对于 peekMax()，我们可以另一个栈来存储每个位置到栈底的所有元素的最大值。例如，如果当前第一个栈中的元素为 [2, 1, 5, 3, 9]，那

么第二个栈中的元素为 [2, 2, 5, 5, 9]。在 push(x) 操作时，只需要将第二个栈的栈顶和 xx 的最大值入栈，而在 pop() 操作时，只需要将第

二个栈进行出栈。

对于 popMax()，由于我们知道当前栈中最大的元素值，因此可以直接将两个栈同时出栈，并存储第一个栈出栈的所有值。当某个时刻，

第一个栈的出栈元素等于当前栈中最大的元素值时，就找到了最大的元素。此时我们将之前出第一个栈的所有元素重新入栈，并同步更新

第二个栈，就完成了 popMax() 操作。


class MaxStack {
    Stack<Integer> xStack;
    Stack<Integer> maxStack;

    public MaxStack() {
        xStack = new Stack<>();
        maxStack = new Stack<>();
    }

    public void push(int x) {
        xStack.push(x);
        int max = maxStack.isEmpty() ? x : maxStack.peek();
        maxStack.push(Math.max(max, x));
    }

    public void pop() {
        xStack.pop();
        maxStack.pop();
    }

    public void popMax() {
        Integer max = maxStack.pop();
        Stack<Integer> buffer = new Stack<>();
        while (!xStack.isEmpty()) {
            Integer cur = xStack.pop();
            if (!Objects.equals(cur, max)) {
                buffer.push(cur);
            }
        }

        while (!buffer.isEmpty()){
            xStack.push(buffer.pop());
        }
    }

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

    public int getMax() {
        return maxStack.peek();
    }
}