leetcode刷题之栈相关

• q20 有效的括号
  题目描述：给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。有效字符串需满足：左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。
  思考：本题在里力扣中的难度属于简单，数据结构中学到栈一般也会涉及此题。其核心思想无非就是配对，且必须以正确的顺序配对。那我们的思路就是，遇到左边括号就让其进栈，遇到右边括号就让栈顶的元素出栈并判断是否与左边括号相匹配，不匹配就是false，值得注意的是需要注意栈是否为空。最后字符串s遍历完以后，需要判断栈是否为空，不为则表示还有括号未配对，则自然就是失败。

public boolean isValid(String s) {
        Stack<Character> stack = new Stack<Character>();
        //循环遍历字符串
        for(char ch : s.toCharArray()){
            //入栈的三种情况
            if (ch == '(' || ch == '[' || ch == '{') {
                stack.push(ch);
            }
            //右括号对比，其中注意为空的情况
            if (ch == ')') {
                if( stack.isEmpty() || stack.pop() != '(') {
                    return false;
                }
            }
            if (ch == ']') {
                 if (stack.isEmpty() || stack.pop() != '[') {
                    return false;
                 }
            }
             if (ch == '}') {
                 if (stack.isEmpty() || stack.pop() != '{') {
                    return false;
                }
            }
        }
        //遍历结束的情况
        if (!stack.isEmpty()) {
            return false;
        }
        return true;   
    }

• q32 最长有小括号
  题目描述： 给你一个只包含 '(' 和 ')' 的字符串，找出最长有效（格式正确且连续）括号子串的长度。
  思考：最长有效括号字串，格式正确且连续。本题要用到栈，那么需要遍历字符串，找到左括号就将其进栈，否则的话，

public int longestValidParentheses(String s) {
        //判断特殊情况
         if (s == null || s.length() < 2) {
            return 0;
        }
         
        int maxLen = 0;
        Stack<Integer> stack = new Stack<>();
        stack.push(-1);
        for (int i = 0; i < s.length(); i++) {
            char temp = s.charAt(i);
            if (temp == '(') {
                stack.push(i);
            } else {
                stack.pop();
                if (stack.empty()) {
                    stack.push(i);
                } else {
                    maxLen = Math.max(maxLen, i - stack.peek());
                }
            }
        }

        return maxLen;

    }

• q155 最小栈
  题目描述：设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
  思考：我们可以每次进栈，都让栈顶元素与新进栈元素比较，把小的那一个放在栈顶。假如我们进栈元素是12345，经过下列算法进栈之后就是1121314151，这样的话，删除栈顶元素都需要进行两次操作。

 private Stack<Integer> stack;

    /** initialize your data structure here. */
    public MinStack() {
         stack = new Stack<>();
    }
    //
    public void push(int val) {
        //如果栈是空的，让当前元素两次进栈，
        if (stack.isEmpty()) {
            stack.push(val);
            stack.push(val);
        } else {
        //不为空的话，设置临时变量tmp为栈顶元素，并让新进栈元素与栈顶元素比较，谁小，谁再一次进栈，通过这样保证最小元素一直在栈顶
            int tmp = stack.peek();
            stack.push(val);
            if (tmp < val) {
                stack.push(tmp);
            } else {
                stack.push(val);
            }
        }
    }
    //删除最小值以及栈顶元素
    public void pop() {
         stack.pop();
         stack.pop();
    }
    //用于返回栈顶元素值
    public int top() {
        return stack.get(stack.size() - 2);
    }
    //获取栈中最小元素值
    public int getMin() {
        return stack.peek();
    }