算法通关村第四关[白银挑战]-栈的经典算法问题

1.括号匹配问题(LeetCode20🟩)

中比较麻烦的是如何判断两个符号是不是一组的，我们可以用哈希表将所有符号先存储，左半边做key,右半边做value。遍历字符串的时候，遇到左半边符号就入栈，遇到右半边符号就与栈顶的符号比较，不匹配就返回false

 /** 
     * @param s
     * @return boolean
     */
    static boolean isValid(String s) {
    	//如果字符串没有或只有一个符号肯定是不匹配的
        if (s.length() <= 1) {
            return false;
        }
        //把这些括号都存入HashMap
        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()) {
                    Character left = stack.pop();
                    char rightchar = smap.get(left);
                    if (rightchar != item) {
                        return false;
                    }
                } else {
                //如果字符串没遍历完栈都空了,说明右部分符号都没有,匹配不上,直接false
                    return false;
                }
            }
        }
        //最后如果栈空,说明都匹配上了
        return stack.isEmpty();
    }

2.最小栈(LeetCode155🟨)

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

这里的关键是理解对应的Min栈内，中间元素为什么是-2
题目要求在常数时间内获得栈中的最小值，因此不能在 getMin0 的时候再去计算最小值，最好应该在push 或者 pop 的时候就已经计算好了当前栈中的最小值。
对于栈来说，如果一个元素 a 在入栈时，栈里有其它的元素 b,c,d，那么无论这个栈在之后经历了什么操作，只要 a 在栈中，b,c,d 就一定在栈中，因为在 a 被弹出之前，b,c,d 不会被弹出。
因此，在操作过程中的任意一个时刻，只要栈顶的元素是 a，那么就可以确定栈里面现在的元素一定是 a,b,c, d。
那么可以在每个元素 a 入栈时把当前栈的最小值 m 存储起来。在这之后无论何时，如果栈顶元素是 a，就可以直接返回存储的最小值 m。
按照上面的思路，只需要设计一个数据结构，使得每个元素 与其相应的最小值 m 时刻保持一一对应。因此我们可以使用一个辅助栈，与元素栈同步插入与删除，用于存储与每人元素对应的最小值。

• 当一个元素要入栈时，取当前辅助栈的栈顶存储的最小值，与当前元素比较得出最小值，将这个最小值插入辅助栈中:
• 当一个元素要出栈时，把辅助栈的栈顶元素也一并弹出

在任意一个时刻，栈内元素的最小值就存储在辅助栈的栈顶元素中。

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

    public MinStack() {
        xStack = new Stack<Integer>();
        minStack = new Stack<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 类:


本题与上一题的相反，但是处理方法是一致的。一个普通的栈可以支持前三种操作 push(x)，pop()和top()，所以我们需要考虑的仅为后两种操作 peekMax()和 popMax()。
对于 peekMax()，我们可以另一个栈来存储每人位置到栈底的所有元素的最大值。例如，如果当前第一个栈中的元素为 [2,1,5,3,9]，那么第二个栈中的元素为[ 2,2,5,5,9]。在 push(x) 操作时，只需要将第二个栈的栈顶和 xx 的最大值入栈，而在 pop0 操作时，只需要将第二个栈进行出栈。
对于 popMax()，由于我们知道当前栈中最大的元素值，因此可以直接将两个栈同时出栈，并存储第一个栈出栈的所有值。当某个时刻，第一人栈的出栈元素等于当前栈中最大的元素值时，就找到了最大的元素。此时我们将之前出第一个栈的所有元素重新入栈，并同步更新第二个栈，就完成了 popMax()操作

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

    public MaxStack() {
        stack = new Stack();
        maxStack = new Stack();
    }

    public void push(int x) {
        int max = maxStack.isEmpty() ? x : maxStack.peek();
        maxStack.push(max > x ? max : x);
        stack.push(x);
    }

    public int pop() {
        maxStack.pop();
        return stack.pop();
    }

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

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

    public int popMax() {
        int max = peekMax();
        Stack<Integer> buffer = new Stack();
        while (top() != max) buffer.push(pop());
        pop();
        while (!buffer.isEmpty()) push(buffer.pop());
        return max;
    }
}