leetcode日记10

day10

---

例题 leetcode 20.有效的括号

链接：https://leetcode.cn/problems/valide-parentheses/

思路：用栈来存储字符串中碰到的左括号的对应右括号。如果碰到右括号就和栈底的元素比较，由于栈的数据结构特性，
先碰到的左括号对应的右括号将会被存在栈顶，最后出来。由此一一比较，总共三种情况会使得括号不匹配：

• 右括号不够
• 右括号溢出
• 对应位置的右括号不匹配

做好讨论即可解决问题。

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

---

例题 leetcode 1047. 删除字符串中的所有相邻重复项

链接：https://leetcode.cn/problems/remove-all-adjacent-duplicates-in-string/

思路1：核心是要不断判断消除相邻重复项之后的字符串是否有出现新的相邻重复项。所以我采用了栈来做。

class Solution {
    public String removeDuplicates(String S) {
        Stack<Character> stack = new Stack<>();
        char ch;
        for (int i = 0; i < S.length(); i++) {
            ch = S.charAt(i);
            if (stack.isEmpty() || stack.peek() != ch) {
                stack.push(ch);
            } else {
                stack.pop();
            }
        }
        String str = "";
        //剩余的元素即为不重复的元素
        while (!stack.isEmpty()) {
            str = stack.pop() + str;
        }
        return str;
    }
}

思路2：双指针法

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);
    }
}

---

例题 leetcode 150. 逆波兰表达式求值

链接：https://leetcode.cn/problems/evaluate-reverse-polish-notation/

思路：因为是逆波兰表达式本质上是后序遍历的表达式，要做的就是每次碰到运算符的时候进行运算并将结果保存在栈中。
从而将表达式进行正确的运算。

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

---