LeetCode刷题之栈

• Valid Parentheses(有效的括号)-Number20

思路：

    括号匹配题是栈的典型应用，因为只有三种类型的括号，我们将右括号作为键，左括号作为值，进行Hash存储，接着对括号表达式进行遍历，遇到左括号我们压入栈中，遇到右括号的时候，则判断该括号对应的左括号是否在栈顶，如果在，则弹出，匹配成功，接着遍历，直到遍历完表达式。否则返回false

代码：

class Solution {
    public boolean isValid(String s) {
        HashMap<Character,Character> mapping = new HashMap<>();
        mapping.put(')','(');
        mapping.put(']','[');
        mapping.put('}','{');
        
        Stack<Character> stack = new Stack<>();
        for(int i=0;i<s.length();i++){
            char c = s.charAt(i);
            if(mapping.containsKey(c))//遍历到右括号
            {
                char topElement = stack.empty()?'#':stack.pop();
                if(topElement!=mapping.get(c))
                    return false;
            }else{ //左括号
                stack.push(c);
            }
        }
        return stack.isEmpty();
    }   
}

• Longest Valid Parentheses-Number32

思路：

    求最长xxx的问题可以想到使用动态规划来求解。用一个数组dp来记录由s[i]作为最后一个字符的字符串的substring的长度。

每个字符s[i]的情况如下：

   当字符为：'(' 时：dp[i] = 0 ，因为 '(' 不可能是任意一个合法括号的结尾

   当字符为：')'时，分两种情况：当s[i-1] = '('时，最长长度增加2，因为增加了一组括号"()"， 此时dp[i] = dp[i-2]+2

                                                    当s[i-1] =‘)’时，情况比较复杂，s[i-1]可能是一个合法括号组的结尾，我们需要找出以s[i-1]为结尾的subString之前的那个元素。这种情况下，要看s[i]与s[i-1-dp[i-1]]是否匹配，匹配的话dp[i] = dp[i-1]+2,否则dp[i]=0

代码：

class Solution {
  public int longestValidParentheses(String s) {
    int maxlen = 0;
    int[] dp = new int[s.length()]; //用来记录由s[i]作为最后一个字符的字符串的substring的长度
    for (int i = 1; i < dp.length; i++) {
      if (s.charAt(i) == ')') {
        if (s.charAt(i-1) == '(') { //当s[i-1]='('时
          dp[i] = (i >= 2 ? dp[i-2] : 0) + 2;
        } else {  //当s[i-1]=')'时
          if (i-dp[i-1]-1 >= 0) { 
            dp[i] = s.charAt(i-dp[i-1]-1) == '(' ? dp[i-1] + 2 : 0;

            if (i - dp[i] >= 0)
              dp[i] += dp[i - dp[i]];
          }
        }
        maxlen = dp[i] > maxlen ? dp[i] : maxlen;
      }
    }
    return maxlen;
  }
}

•     Evaluate Reverse Polish Notation (求逆波兰表达式)-Number150

思路：

     表达式求值是栈的基本引用，遇到数字则压栈，遇到表达式则弹出两个数进行计算，并将结果压入栈中

代码：  

class Solution {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for(int i=0;i<tokens.length;i++){
            if(tokens[i].equals("+")|| tokens[i].equals("-")||
               tokens[i].equals("*")||tokens[i].equals("/")){
                int a = stack.pop();
                int b = stack.pop();
                if(tokens[i].equals("+")){
                    stack.push(a+b);
                }else if(tokens[i].equals("-"))
                    stack.push(b-a);
                else if(tokens[i].equals("*"))
                    stack.push(a*b);
                else if(tokens[i].equals("/"))
                    stack.push(b/a);
            }else{
                stack.push(Integer.parseInt(tokens[i]));
            }
        }
        return stack.pop();
    }
}