6.比较含退格的字符串（力扣字符串）（两种解法：字符串操作，栈）

目录

题目链接

法一：普通字符串操作

法二：栈操作

---

题目链接

. - 力扣（LeetCode）

法一：普通字符串操作

用len1记录目前s的字符个数，len2记录目前t的字符个数

如果不是#，则s[len1] = s[i]

如果是#，则len1--（也就是#不放入，且上一个放入的字符会被下一个字符覆盖）

//法一：普通字符串操作
class Solution
{
public:
    bool backspaceCompare(string s, string t)
    {
        if (s.size() == 0 && t.size() == 0)
            return true;

        int len1 = 0, len2 = 0;
        for (int i = 0; i < s.size(); i++)
        {
            if (s[i] == '#')
            {//如果是#，则len1--（也就是#不放人，且上一个放入的字符会被下一个字符覆盖）
                if (len1 > 0)
                    len1--;
            }
            else
            {//如果不是#，则s[len1] = s[i]
                s[len1] = s[i];
                len1++;
            }
        }
        s[len1] = '\0';
        for (int i = 0; i < t.size(); i++)
        {
            if (t[i] == '#')
            {
                if (len2 > 0)
                    len2--;
            }
            else
            {
                t[len2] = t[i];
                len2++;
            }
        }
        t[len2] = '\0';

        cout << s << endl << t << endl;

        if (len1 != len2)
            return false;

        if (len1 == 0 && len2 == 0)
            return true;

        int j = 0;
        for (int i = 0; i < len1; i++, j++)
        {
            if (s[i] != t[j])
                return false;
        }

        return true;
    }
};

法二：栈操作

如果不是#，则将该元素入栈

如果是#，弹出栈顶（#前面的字符被弹出），注意：栈为空的时候不可弹栈

最后将s和t改为栈内元素，注意栈的后进先出的特性

//法二：栈
 class Solution
 {
 public:
     bool backspaceCompare(string s, string t)
     {
         if (s.size() == 0 && t.size() == 0)
             return true;

         stack<char>st1, st2;
         int len1, len2;

         int count = s.size();//记录s最后的字符个数
         for (int i = 0; i < s.size(); i++)
         {
             if (s[i] != '#')
             {//如果不是#，则将该元素入栈                 
                 st1.push(s[i]);
             }
             else
             {//如果是#，弹出栈顶，注意：栈为空的时候不可弹栈
                 if (!st1.empty())
                 {
                     //减去# 和 #前面的那个字符占的字符数
                     count -= 2;
                     st1.pop();
                 }
                 else
                 {
                     //减去#占的字符数
                     count--;
                 }
             }
         }
         if (count == 0)
         {
             s = "";
             len1 = 0;
         }
         else
         {//栈后进先出，所以倒着更新
             for (int i = count - 1; i >= 0; i--)
             {
                 s[i] = st1.top();
                 st1.pop();
             }
             len1 = count;
         }

         count = t.size();
         for (int i = 0; i < t.size(); i++)
         {
             if (t[i] != '#')
             {
                 st2.push(t[i]);
             }
             else
             {
                 if (!st2.empty())
                 {
                     //减去# 和 #前面的那个字符占的字符数
                     count -= 2;
                     st2.pop();
                 }
                 else
                 {
                     //减去 # 占的字符数
                     count--;
                 }
             }
         }


         if (len1 != count)
             return false;

         if (count == 0)
         {
             t = "";
             len2 = 0;
         }
         else
         {
             for (int i = count - 1; i >= 0; i--)
             {
                 t[i] = st2.top();
                 st2.pop();
             }
             len2 = count;
         }

         if (len1 != len2)
             return false;
         if (len1 == 0 && len2 == 0)
             return true;

         int j = 0;
         for (int i = 0; i < len1; i++, j++)
         {
             if (s[i] != t[j])
                 return false;
         }
         return true;
     }
 };