力扣 844. 比较含退格的字符串

使用方法有双指针（反向）比较法和双指针（正向）遍历法，关键点在于（反向）比较法中的使用skipS和skipT来存放未处理的'#'数量协助反向比较字符（一旦出现一个不匹配的字符就返回false），以及返回true和false条件有多种。

双指针（反向）比较法：时间复杂度：O(n)，空间复杂度：O(1)

双指针（反向）比较法思路：

1. 创建两个指针indexS和indexT分别指向s和t的末位字符，再创建两个变量skipS和skipT用来存放遇到了但还未处理的'#'数量。
2. 从后往前遍历s，有三种情况：
   1. 若当前字符是'#'，则skipS自增1
   2. 若当前字符不是'#'，且skipS不为0（说明该字符要被退格掉），则skipS自减1
   3. 若当前字符不是'#'，且skipS为0（说明当前字符不会被退格），则将当前字符与t的当前字符作比较
3. 从后往前遍历t，情况与2相同。
4. 若对比过程出现s, t当前字符不匹配，则遍历结束，返回false。若遍历结束后，且都能匹配，则返回true。

双指针（反向）比较法代码：

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int indexS = s.length() - 1;
        int indexT = t.length() - 1;
        int skipS = 0, skipT = 0;

        while (indexS >= 0 || indexT >= 0) {
            while (indexS >=0) {
                if (s[indexS] == '#') {
                    skipS++;
                    indexS--;
                }else if (s[indexS] != '#' && skipS != 0) {
                    skipS--;
                    indexS--;
                }else if (s[indexS] != '#' && skipS == 0) { //找到s中第一个需要比较的字符
                    break;
                }
            }

            while (indexT >= 0) {
                if (t[indexT] == '#') {
                    skipT++;
                    indexT--;
                }else if (t[indexT] != '#' && skipT != 0) {
                    skipT--;
                    indexT--;
                }else if (t[indexT] != '#' && skipT == 0) { //找到t中第一个需要比较的字符
                    break;
                }
            }
            
            if (indexS >= 0 && indexT >=0) {
                if (s[indexS--] != t[indexT--]) { //如果待比较字符不同，return false
                    return false;
                }
            }else if (indexS >= 0 || indexT >=0) { 
                // (indexS >= 0 && indexT >= 0) 为 false 情况为
                // 1. indexS < 0  && indexT >= 0
                // 2. indexS >= 0 && indexT < 0
                // 3. indexS < 0  && indexT < 0
                // 情况1和2是因为s和t其中一个是在 index >= 0 处找到了待比较字符，
                // 另一个没有找到，应当返回 False。
                // 但是情况3中s和t都是 index = 0 的位置为 '#' ，
                // 而这种情况下退格空字符即为空字符，也应当返回 True。
                return false;
            }
        }
        return true;
    }
};

双指针（正向）遍历法：时间复杂度：O(n)，空间复杂度：O(1)

双指针（正向）遍历法思路：

1. 创建快慢指针遍历字符串，遍历字符串s。当快指针遇到非'#'号时，将快指针指向的值赋给慢指针的位置，慢指针++。
2. 当快指针遇到'#'号时，慢指针回退一格，也就是慢指针--，注意慢指针的值不能为负。
3. 对字符串t做一遍相同的操作。
4. 比较两个字符串的前slowIndex项是否相同，相同则返回True，否则返回False。

双指针（正向）遍历法代码：

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < s.length(); fastIndex++) {
            if (s[fastIndex] != '#') { //遇到非#元素向前移动
                s[slowIndex] = s[fastIndex];
                slowIndex++;
            }else if (s[fastIndex] == '#' && slowIndex > 0) { //遇到#号慢指针回退
                slowIndex--;
            }
        }

        int slowIndex2 = 0;
        for (int fastIndex2 = 0; fastIndex2 < t.length(); fastIndex2++) {
            if (t[fastIndex2] != '#') {
                t[slowIndex2] = t[fastIndex2];
                slowIndex2++;
            }else if (t[fastIndex2] == '#' && slowIndex2 > 0) {
                slowIndex2--;
            }
        }

        if (slowIndex == slowIndex2) {  //两个新字符串有相等数量的字符才比较
            for (int i = 0; i < slowIndex; i++) {
                if (s[i] != t[i]) {
                    return false;
                }
            }
            return true;
        }else
            return false;
    }
};