代码随想录算法训练营第十一天|LeetCode20.有效括号|LeetCode1047.删除字符串中的所有相邻重复项|LeetCode150.逆波兰表达式

LeetCode20.有效括号

        基本思路：使用一个栈stack，如果字符串的长度不是2的倍数，直接返回。遍历整个字符串，如果为括号的左边，则入栈对应的右边括号，如果不是且栈为空且栈顶元素不等于当前遍历到的字符的时候，返回false，因为没有找到匹配的括号，反之就是找到了，栈顶元素出栈。如果循环结束，栈不为空的话，说明所有元素都找到了对于的括号，反之就没有。

Java代码如下：

public boolean isValid(String s) {
        if(s.length() % 2 != 0)
        {
            return false;
        }
        Deque<Character> stack = new LinkedList<>();
        for(int i = 0; i < s.length() ; i++)
        {
            char c = s.charAt(i);
            if(c == '(')
            {
                stack.push(')');
            }else if(c == '[')
            {
                stack.push(']');
            }else if(c == '{')
            {
                stack.push('}');
            }else if(stack.isEmpty() || stack.peek() != c)
            {
                return false;
            }else{
                stack.pop();
            }

        }
        return stack.isEmpty();
    }

 

 LeetCode1047.删除字符串中的所有相邻重复项

        基本思路：使用一个栈stack，遍历当前的字符串，如果stack为空的话就直接入栈，如果不为空，就和栈顶元素进行比较，如果相等，就出栈然后进行下一个循环，如果不想等就入栈。循环结束之后，返回的结果需要反向。

Java代码如下：

public String removeDuplicates(String s) {
        Deque<Character> stack = new LinkedList<>();
        for(int i = 0; i < s.length() ; i++)
        {
            char c = s.charAt(i);
            if(stack.isEmpty())
            {
                stack.push(c);
                continue;
            }
            if(stack.peek() == c)
            {
                stack.pop();
            }else{
                stack.push(c);
            }
        }
        String res = "";
        while(!stack.isEmpty())
        {
             res = stack.pop() + res;
        }
        return res;
    }

 

LeetCode150.逆波兰表达式

        逆波兰表达式：是一种后缀表达式，所谓后缀就是指运算符写在后面。

平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。

该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

（1）去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。

（2）适合用栈操作运算：遇到数字则入栈；遇到运算符则取出栈顶两个数字进行计算，并将结果压入栈中。

        基本思路：遍历整个字符串，当拿到的字符不是运算符的话，就直接转成int入栈，如果是运算符的话，就需要对之前的数进行相应的运算操作。最后循环结束，栈里面剩下一个结果，返回即可。

Java代码如下：

    public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new LinkedList<>();
        for(String s : tokens)
        {
            if(s.equals("+"))
            {
                stack.push(stack.pop() + stack.pop());
            }else if(s.equals("-")){
                stack.push(-stack.pop() + stack.pop());
            }else if(s.equals("*")){
                stack.push(stack.pop() * stack.pop());
            }else if(s.equals("/")){
                int temp1 = stack.pop();
                int temp2 = stack.pop();
                stack.push(temp2 / temp1);
            }else{
                stack.push(Integer.valueOf(s));
            }
        }
        return stack.pop();
    }