算法通关村（四）| 栈的经典算法

括号匹配问题

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

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

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

思路分析

使用哈希表和栈来解决，将三种括号放入哈希表中，然后使用栈来比对

public static boolean isValid(String s) {
    if (s.length() <= 1) return false;
    Map<Character, Character> map = new HashMap<>();
    map.put('(',')');
    map.put('{','}');
    map.put('[',']');

    Stack<Character> stack = new Stack();
    for (int i = 0; i < s.length(); i++) {
        char c = s.charAt(i);
        if (map.containsKey(c)) {
            stack.push(c);
        }else {
            if (!stack.isEmpty()){
                Character pop = stack.pop();
                Character value = map.get(pop);
                if (value != c) return false;
            }else {
                return false;
            }
        }
    }
    return stack.isEmpty();
}

最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈

实现MinStack类
MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。

思路分析

如果说元素a入栈时，栈里有其他元素bcd。那么无论这个栈如何操作，只要a在栈中，bcd就一定在栈中。因此在操作过程中，只要栈顶是a，那么现在栈内元素一定是abcd

我们可以在每个元素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();
    }
}

最大栈

设计一个最大栈数据结构，既支持栈操作，又支持查找栈中最大元素

实现 MaxStack 类：
MaxStack() 初始化栈对象
void push(int x) 将元素 x 压入栈中。
int pop() 移除栈顶元素并返回这个元素。
int top() 返回栈顶元素，无需移除。
int peekMax() 检索并返回栈中最大元素，无需移除。
int popMax() 检索并返回栈中最大元素，并将其移除。如果有多个最大元素，只要移除 最靠近栈顶 的那个。

思路分析

peekMax和上一题的实现方式相同。popMax方法需要创建一个新栈buffer，将stack中不等于max的值都入buffer栈，删除max值，然后依次出栈重新进入stack栈

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

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

    public void push(int x) {
        maxStack.push(Math.max(maxStack.isEmpty() ? x : maxStack.peek(), 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;
    }
}