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

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

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

这道题是模拟的字符的回删操作，拿到这个题目我的第一反应是用栈数据结构去处理，因为它有一个先进后出的回删操作，具体C++实现代码如下：

class Solution {
     
public:
    bool backspaceCompare(string S, string T) {
     
        stack<char> my_stackS;
        stack<char> my_stackT;
        for(auto& ch: S)
        {
     
            if(ch=='#') 
            {
     
                if(!my_stackS.empty()) my_stackS.pop();
            }
            else my_stackS.push(ch);
        }
        for(auto& ch: T)
        {
     
            if(ch=='#') 
            {
     
                if(!my_stackT.empty()) my_stackT.pop();
            }
            else my_stackT.push(ch);
        }
        while(!my_stackS.empty()||!my_stackT.empty())
        {
     
            char tmpS;
            char tmpT;
            if (!my_stackS.empty())
            {
     
                tmpS=my_stackS.top();
                my_stackS.pop();
            } 
            else tmpS=' ';
            if (!my_stackT.empty()) 
            {
     
                tmpT=my_stackT.top();
                my_stackT.pop();
            }
            else tmpT=' ';
            if(tmpT!=tmpS) return false;
            if((!my_stackS.empty()&&my_stackT.empty())||(my_stackS.empty()&&!my_stackT.empty())) return false;
        }
        return true;
    }
};

运行效果：

这个思路的时间复杂度为O(M+N)，由于要使用两个栈数据结构，所以空间复杂度也是O(M+N)。官方给出的思路是栈数据结构和双指针（感觉每次都被官方打脸），下面我们用Python实现一下双指针的思路：

class Solution:
    def backspaceCompare(self, S: str, T: str) -> bool:
        IndexS=len(S)-1
        IndexT=len(T)-1
        NumS=0
        NumT=0
        while (IndexS>=0 or IndexT>=0):
            while (IndexS>=0):
                if(S[IndexS]=='#'):
                    NumS+=1
                    IndexS-=1
                elif NumS>0:
                    NumS-=1
                    IndexS-=1
                else:
                    break
            while(IndexT>=0):
                if(T[IndexT]=='#'):
                    NumT+=1
                    IndexT-=1
                elif NumT>0:
                    NumT-=1
                    IndexT-=1
                else:
                    break
            if (IndexS>=0 and IndexT>=0):
                if(S[IndexS]!=T[IndexT]):
                    return False
            elif (IndexS>=0 or IndexT>=0):
                return False
            IndexS-=1
            IndexT-=1
        return True

运行效果：

该思路采用两个从尾节点开始回退的指针记录字符串的字符，当遇到‘#’时对#号本身和前面的字符进行跳过处理，最后比较两个指针指向的字符是否一致。（不得不吐槽一下python是真的慢）

来源：力扣（LeetCode）链接