算法：栈相关经典算法题目

栈相关题目

一、20. 有效的括号

1.1 解法一： 使用Stack栈（FILO）来实现（可以使用双端队列代替）

    public boolean isValid(String s) {
        Deque<Character> deque = new LinkedList<>();
        Map<Character, Character> map = new HashMap<>(3);
        map.put(')', '(');
        map.put('}', '{');
        map.put(']', '[');
        for (int i=0; i<s.length(); i++) {
            char c = s.charAt(i);
            if (!map.containsKey(c)) {
                deque.addFirst(c);
            }else {
                if (deque.isEmpty() || deque.peek()!=map.get(c)) return false;
                deque.removeFirst();
            }
        }
        return deque.isEmpty();
    }

二、155. 最小栈

2.1 解法一：自定义栈

栈：先进先出。最小栈：每个节点保留最小值；

class MinStack {

    private Node first;
    private int N;

    private class Node {
        private int val;
        private int min;
        private Node next;
        public Node(int val, int min) {
            this.val = val;
            this.min  = min;
        }

    }

    public MinStack() {
    }

    public int size() {
        return N;
    }

    public boolean isEmpty() {
        return size()==0;
    }
    
    public void push(int val) {
        if (isEmpty()) {
            first = new Node(val, val);
        }else {
            Node oldFirst = first;
            first = new Node(val, Math.min(val, first.min));
            first.next = oldFirst;
        }
        N++;
    }
    
    public void pop() {
        if (isEmpty()) return;
        first = first.next;
        N--;
    }
    
    public int top() {
        if (isEmpty()) throw new RuntimeException("None item");
        return first.val;
    }
    
    public int getMin() {
        if (isEmpty()) throw new RuntimeException("None item");
        return first.min;
    }
}

2.2 解法二：使用辅助栈

class MinStack {

    private Deque<Integer> stack;
    private Deque<Integer> minStack;

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

三、84. 柱状图中最大的矩形 , 经常回过来看看

3.1 解法一：暴力求解，时间超限

    public int largestRectangleArea(int[] heights) {
        int max = 0;
        for (int i=0; i<heights.length; i++) {
            int minH = heights[i];
            for (int j=i; j<heights.length; j++) {
                minH = Math.min(heights[j], minH);
                int area = (j-i+1) * minH;
                max = Math.max(area, max);
            }
        }
        return max;
    }

3.2 解法二：暴力求解的优化，（以当前角标值作为高度）,时间超限

    public int largestRectangleArea(int[] heights) {
        int max = 0;
        for (int k=0; k<heights.length; k++) {
            // 找左边界 和右边界
            int l = k-1, r = k+1;
            while (l>=0 && heights[l]>=heights[k]) l--;
            while (r<=heights.length-1 && heights[r]>=heights[k]) r++;
            int area = (r-l-1) * heights[k];
            max = Math.max(area, max);
        }
        return max;
    }

3.3 解法三：用栈来解决

基于“以当前角标对应的值作为高，再获取到左边界、和右边界，进来计算出面积”

维护一个递增的栈（栈里面存放角标），这样左边界就确定了。

因为是递增，如果进栈元素比栈顶的元素小，那边右边界就也能确定了。

(1) 根据这个思路，自己写：

    public int largestRectangleArea(int[] heights) {
   
   
        Deque<Integer> deque = new LinkedList<>();
        deque.addFirst(-1);
        int max=0;
        for (int i=0; i<=heights.length; i++) {
   
   
            if (i==heights.length || (deque.peek()!=-