判断字符为空_力扣 844. 比较含退格的字符串

844. 比较含退格的字符串

题目描述

给定 S 和 T 两个字符串，当它们分别被输入到空白的文本编辑器后，判断二者是否相等，并返回结果。# 代表退格字符。

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

示例 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 = "#a#c"
输出：true
解释：S 和 T 都会变成 “c”。

示例 4：

输入：S = "a#c", T = "b"
输出：false
解释：S 会变成 “c”，但 T 仍然是 “b”。

提示：

1. 1 <= S.length <= 200
2. 1 <= T.length <= 200
3. S 和 T 只含有小写字母以及字符 '#'。

进阶：

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

❝

来源：力扣(LeetCode)
链接：https://leetcode-cn.com/problems/backspace-string-compare
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

使用列表模拟栈

比较直观的思路是顺次扫描 S 和 T 的每一个字符，把它们存在列表中：

• 如果扫描到的是 # 字符，则从列表末尾弹出一个元素，当然在这之前要检查列表是否为空，如果为空就不用弹栈。
• 对 S 和 T 都应用这种算法，最终比较两者结果是否相等。

这样的解法时间复杂度为 ，空间复杂度也为 。

class Solution:
    def backspaceCompare(self, S: str, T: str) -> bool:
        def get_string(s):
            res = []
            for c in s:
                if c == '#':
                    if res:
                        res.pop()
                else:
                    res.append(c)
            return ''.join(res)
        return get_string(S) == get_string(T)

运行结果：

❝

执行结果：通过
执行用时：40 ms, 在所有 Python3 提交中击败了77.02% 的用户
内存消耗：13.6 MB, 在所有 Python3 提交中击败了5.32% 的用户

---

逆序双指针

题目的进阶要求的时间复杂度是 ，空间复杂度是 。这又是需要把空间复杂度从 降低到 的题目，跟昨天做的 19. 删除链表的倒数第N个节点一样，都涉及到了指针。

具体做法是从末尾开始同时遍历并比较 S 和 T 的字符：

• 如果碰到 #，则之后需要跳过的字符数 skip 加 1
• 如果碰到普通字符，当 skip == 0 的时候，不用跳过该字符，可以直接用于比较
• 如果碰到普通字符，但 skip > 0 的时候，需要跳过该字符，并让 skip -= 1

class Solution:
    def backspaceCompare(self, S: str, T: str) -> bool:
        i, j = len(S) - 1, len(T) - 1
        skipi = skipj = 0
        while i >= 0 or j >= 0:
            while i >= 0:
                if S[i] == '#':
                    skipi += 1
                    i -= 1
                    continue
                if not skipi:
                    break
                i -= 1
                skipi -= 1
            while j >= 0:
                if T[j] == '#':
                    skipj += 1
                    j -= 1
                    continue
                if not skipj:
                    break
                j -= 1
                skipj -= 1
            if i == j == -1:
                return True
            if i 0 or j 0:
                return False
            if S[i] != T[j]:
                return False
            i -= 1
            j -= 1
        return True

运行结果：

❝

执行结果：通过
执行用时：32 ms, 在所有 Python3 提交中击败了97.75% 的用户
内存消耗：13.5 MB, 在所有 Python3 提交中击败了10.96% 的用户

---

2020.10.19