【LeetCode】844. 比较含退格的字符串（Java）

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

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

提示：

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

进阶：

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

解法一

双栈，个人解法，解法二和三借鉴官方的题解，满足进阶的要求的应该就只有双指针了，时间复杂度为O(N+M)，空间复杂度为O(1)。

class Solution {
    public boolean backspaceCompare(String S, String T) {
        //双栈
        Deque<Character> sStack = new ArrayDeque<>();
        Deque<Character> tStack = new ArrayDeque<>();

        //把字符放到栈中
        build(S, sStack);
        build(T, tStack);

        //如果长度不相等，直接返回false
        if (sStack.size() != tStack.size()) return false;
        //循环比较
        int size = sStack.size();
        for (int i = 0; i <size; i++) {
            if (sStack.pollLast() != tStack.pollLast()) {
                return false;
            }
        }
        return true;
    }

    private void build(String str, Deque<Character> stack) {
        //把S的每个字符放到栈中
        for (char c : str.toCharArray()) {
            if (c != '#') {
                //如果是字母，放到栈中
                stack.offerLast(c);
            } else {
                //如果当前字符为#，并且栈不为空，扔掉栈中一个字符
                if (!stack.isEmpty()) {
                    stack.pollLast();
                }
            }
        }
    }
}

解法二

StringBuilder

class Solution {
    public boolean backspaceCompare(String S, String T) {
    //StringBuilder
    //比较重构后的字符串
    return build(S).equals(build(T));
    }

    private String build(String str) {
        StringBuilder res = new StringBuilder();
        for (char c : str.toCharArray()) {
            //如果当前字符为字母，添加到res中
            if (c != '#') {
                res.append(c);
            } else {
                //如果当前字符为#，并且res长度不为0，删除res中最后一个字符
                if (res.length() != 0) {
                    res.deleteCharAt(res.length() - 1);
                }
            }
        }
        return res.toString();
    }
}

解法三

双指针

class Solution {
    public boolean backspaceCompare(String S, String T) {
        //双指针
        int s = S.length() - 1, t = T.length() - 1;
        int sSkip = 0, tSkip = 0;   //要回退的个数
        while (s >= 0 || t >= 0) {
            //s指针指向有效的字符
            while (s >= 0) {
                if (S.charAt(s) == '#') {
                    s--;
                    sSkip++;
                } else if (sSkip > 0) {
                    s--;
                    sSkip--;
                } else {
                    break;
                }
            }
            //t指针指向有效的字符
            while (t >= 0) {
                if (T.charAt(t) == '#') {
                    t--;
                    tSkip++;
                } else if (tSkip > 0) {
                    t--;
                    tSkip--;
                } else {
                    break;
                }
            }

            if (s >= 0 && t >= 0) {
                //如果当前指向的不相等，返回false
                if (S.charAt(s) != T.charAt(t)) {
                    return false;
                }
            } else {
                //如果当前有一个指针小于0，返回false
                if (s >= 0 || t >= 0) {
                    return false;
                }
            }
            s--;
            t--;
        }
        return true;
    }
}