LeetCode 844. 比较含退格的字符串

844. 比较含退格的字符串

难度 简单

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

**注意：**如果对空文本输入退格字符，文本继续为空。

示例 1：

输入：s = "ab#c", t = "ad#c"
输出：true
解释：s 和 t 都会变成 "ac"。

示例 2：

输入：s = "ab##", t = "c#d#"
输出：true
解释：s 和 t 都会变成 ""。

示例 3：

输入：s = "a#c", t = "b"
输出：false
解释：s 会变成 "c"，但 t 仍然是 "b"。

提示：

• 1 <= s.length, t.length <= 200
• s 和 t 只含有小写字母以及字符 '#'

进阶：

• 你可以用 O(n) 的时间复杂度和 O(1) 的空间复杂度解决该问题吗？

题解

​ 这道题意图很明显，就去按要求去掉#前面的字符，然后比较是否相等，如果这样做我们就上当了，你会发现操作及其麻烦，边界判断，判断后一个字母是否为#之类的。

解法一

​ 思来想去，才想起来括号匹配和逆波兰式等等，这#不就是一个特殊符号，我们遇到特定的符号进行特定的操作。

class Solution {
    public boolean backspaceCompare(String s, String t) {
        Stack sStack = prepare(s);//s字符串处理完的内容
        Stack tStack = prepare(t);//t字符串处理完的内容
        while(!sStack.empty() && !tStack.empty()){//两个栈都不为空
            char s1 = (char)sStack.pop();//s栈顶元素出栈
            char t1 = (char)tStack.pop();//t栈顶元素出栈
            if(s1 != t1){//不相等直接返回
                return false;
            }
        }
        if(!sStack.empty() || !tStack.empty()){//其中一个栈不为空，匹配不成功
            return false;
        }
        return true;
    }

    public Stack prepare(String s){//预处理
        Stack stack = new Stack();
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) != '#'){//不是#，入栈
                stack.push(s.charAt(i));
            }else{
                if(!stack.empty()){//栈不为空，出栈
                    stack.pop();
                }
            }
        }
        return stack;
    }
}

解法二

​ 本来想到双指针的，但是硬是想不通怎么遍历，原来要从后面开始遍历才行。这时候需要两个辅助变量，一个是指针，一个是记录#的数量。整个遍历的过程可分为两个阶段，处理阶段和判断阶段

• 处理阶段
  • 遇到#，那么我们就要记录数量+1，指针向前移动一个位置
  • 不是#，判断#数量是否大于0
    • 大于0，记录数量-1，指针向前移动一个位置
    • 不大于0，不需要移动
• 判断阶段
  • 两个指针都还大于等于0，如果不相等返回false
  • 其中一个指针小于0，匹配不成功

class Solution {
    public boolean backspaceCompare(String s, String t) {
        int slen = s.length() - 1;//s的长度
        int tlen = t.length() - 1;//t的长度
        int skipS = 0;//记录s遍历到当前指针的#数量
        int skipT = 0;//记录t遍历到当前指针的#数量

        while(slen >= 0 || tlen >=0){
            while(slen >= 0){
                if(s.charAt(slen) == '#'){//遇到#
                    skipS++;
                    slen--;
                }else if(skipS > 0){//#数量大于0，需要移动指针
                    skipS--;
                    slen--;
                }else{
                    break;
                }
            }
            while(tlen >= 0){
                if(t.charAt(tlen) == '#'){//遇到#
                    skipT++;
                    tlen--;
                }else if(skipT > 0){//#数量大于0，需要移动指针
                    skipT--;
                    tlen--;
                }else{
                    break;
                }
            }
            if(slen >= 0 && tlen >= 0){//如果两个指针都大于0
                if(s.charAt(slen) != t.charAt(tlen)){//不匹配，返回false
                    return false;
                }
            }else{
                if(slen >=0 || tlen >= 0){//其中一个字符串遍历结束，不匹配
                    return false;
                }
            }
            slen--;
            tlen--;
        }
        return true;
    }
}