(字符串) 844. 比较含退格的字符串—

(字符串) 844. 比较含退格的字符串——【Leetcode每日一题】

news2024/11/20 23:22:55

❓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)$ 的空间复杂度解决该问题吗？

💡思路：

法一：栈

使用栈将给定的字符串中的退格符 # 和应当被删除的字符都去除；
然后比较栈中两字符串是否相等即可。

法二：优化方法（从后向前双指针）

我们定义两个指针，分别指向两字符串的末尾（ i 初始为 s 末尾，j 初始为 t 末尾），同时从后向前遍历 s 和 t；

再定义 s_skip 和 t_skip 表示当前待删除的字符的数量。

每次我们遍历到一个字符：

该字符为退格符 # ，则我们需要多删除一个普通字符，我们让 skip 加 1；
若该字符为普通字符，让 skip 减 1；。

每次我们让两指针逆序地遍历两字符串，直到两字符串能够各自确定一个字符，然后将这两个字符进行比较。重复这一过程直到找到的两个字符不相等，或遍历完字符串为止。

动画如下：
在这里插入图片描述

🍁代码：(Java、C++)

法一：栈
Java

class Solution {
    public boolean backspaceCompare(String s, String t) {
        Stack<Character> stk1 = new Stack<>();
        Stack<Character> stk2 = new Stack<>();
        for(char c : s.toCharArray()){
            if(c != '#') stk1.push(c);
            else if(!stk1.empty()) stk1.pop();
        }
        for(char c : t.toCharArray()){
            if(c != '#') stk2.push(c);
            else if(!stk2.empty()) stk2.pop();
        }
        if(stk1.size() != stk2.size()) return false;
        while(!stk1.empty()){
            if(stk1.peek() != stk2.peek())return false;
            stk1.pop();
            stk2.pop();
        }
        return true;
    }
}

C++

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        stack<char> stk1, stk2;
        for(char c : s){
            if(c != '#') stk1.push(c);
            else if(!stk1.empty()) stk1.pop();
        }
        for(char c : t){
            if(c != '#') stk2.push(c);
            else if(!stk2.empty()) stk2.pop();
        }
        if(stk1.size() != stk2.size()) return false;
        while(!stk1.empty()){
            if(stk1.top() != stk2.top())return false;
            stk1.pop();
            stk2.pop();
        }
        return true;
    }
};

法二：优化方法（从后向前双指针）
Java

class Solution {
    public boolean backspaceCompare(String s, String t) {
        int i = s.length() - 1, j = t.length() - 1;
        int s_skip = 0, t_skip = 0;
        while(true){
            while(i >= 0 && (s.charAt(i) == '#' || s_skip > 0)){// 从后向前，消除s的#
                if(s.charAt(i) == '#') s_skip++;
                else s_skip--;
                i--;
            }
            while(j >= 0 && (t.charAt(j) == '#' || t_skip > 0)){// 从后向前，消除t的#
                if(t.charAt(j) == '#') t_skip++;
                else t_skip--;
                j--;
            }
            // 后半部分#消除完了，接下来比较s[i] != t[j]
            if (i < 0 || j < 0) break; // s 或者t 遍历到头了
            if (s.charAt(i) != t.charAt(j)) return false;
            i--;j--;
        }
        return i == j;
    }
}

C++

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int i = s.size() - 1, j = t.size() - 1;
        int s_skip = 0, t_skip = 0;
        while(1){
            while(i >= 0 && (s[i] == '#' || s_skip > 0)){// 从后向前，消除s的#
                if(s[i] == '#') s_skip++;
                else s_skip--;
                i--;
            }
            while(j >= 0 && (t[j] == '#' || t_skip > 0)){// 从后向前，消除t的#
                if(t[j] == '#') t_skip++;
                else t_skip--;
                j--;
            }
            // 后半部分#消除完了，接下来比较s[i] != t[j]
            if (i < 0 || j < 0) break; // s 或者t 遍历到头了
            if (s[i] != t[j]) return false;
            i--;j--;
        }
        return i == j;
    }
};