代码随想录day11

一、有效的括号（LeetCode20）

class Solution {
    public boolean isValid(String s) {
        if(s.length() % 2 != 0) return false;
        Stack<Character> res = new Stack<>(); 
        for(int i = 0;i<s.length();i++){
            //碰到左括号，就把相应的右括号入栈
            if(s.charAt(i) == '('){
                res.push(')');
            }else if(s.charAt(i) == '{'){
                res.push('}');
            }else if(s.charAt(i) == '['){
                res.push(']');
            }else if(res.isEmpty() || res.peek() != s.charAt(i)){
                return false;
            }else{
                res.pop(); //如果是右括号判断是否和栈顶元素匹配
            }
        }
        //最后判断栈中元素是否匹配
        return res.isEmpty();
    }
}

二、删除字符串中的所有相邻重复项（LeetCode1047）

栈实现

class Solution {
    public String removeDuplicates(String s) {
        //ArrayDeque会比LinkedList在除了删除元素这一点外会快一点
        //参考：https://stackoverflow.com/questions/6163166/why-is-arraydeque-better-than-linkedlist
        ArrayDeque<Character> res = new ArrayDeque<>();
        char c;
        for(int i = 0;i < s.length();i++){
            c = s.charAt(i);
            if(res.isEmpty() || res.peek() != c){
                res.push(c);
            }else{
                res.pop();
            }
        }
        String str = "";
        //剩余的元素即为不重复的元素
        while (!res.isEmpty()) {
            str = res.pop() + str;
        }
        return str;
    }
}

字符串实现

class Solution {
    public String removeDuplicates(String s) {
        // 将 res 当做栈
        // 也可以用 StringBuilder 来修改字符串，速度更快
        // StringBuilder res = new StringBuilder();
        StringBuffer res = new StringBuffer();
        // top为 res 的长度
        int top = -1;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            // 当 top > 0,即栈中有字符时，当前字符如果和栈中字符相等，弹出栈顶字符，同时 top--
            if (top >= 0 && res.charAt(top) == c) {
                res.deleteCharAt(top);
                top--;
            // 否则，将该字符 入栈，同时top++
            } else {
                res.append(c);
                top++;
            }
        }
        return res.toString();
    }
}

快慢指针

class Solution {
    public String removeDuplicates(String s) {
        char[] ch = s.toCharArray();
        int fast = 0;
        int slow = 0;
        while(fast < s.length()){
            // 直接用fast指针覆盖slow指针的值
            ch[slow] = ch[fast];
            // 遇到前后相同值的，就跳过，即slow指针后退一步，下次循环就可以直接被覆盖掉了
            if(slow > 0 && ch[slow] == ch[slow - 1]){
                slow--;
            }else{
                slow++;
            }
            fast++;
        }
        return new String(ch,0,slow);
    }
}

三、逆波兰表达式求值（LeetCode150）

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new LinkedList<>();
        for(String s : tokens){
            if ("+".equals(s)) {//leetcode 内置jdk的问题，不能使用==判断字符串是否相等
                stack.push(stack.pop() + stack.pop()); // 注意 - 和/ 需要特殊处理
            } else if ("-".equals(s)) {
                stack.push(-stack.pop() + stack.pop());
            } else if ("*".equals(s)) {
                stack.push(stack.pop() * stack.pop());
            } else if ("/".equals(s)) {
                int temp1 = stack.pop();
                int temp2 = stack.pop();
                stack.push(temp2 / temp1);
            } else {
                stack.push(Integer.valueOf(s)); //对字符s强制类型转化int入栈
            }
        }
        return stack.pop();
    }
}