双指针实现删除字符串中的所有相邻重复项

class Solution:
    def removeDuplicates(self, s: str) -> str:
        res = list(s)
        slow = fast = 0
        length = len(res)

        while fast < length:
            # 如果一样直接换，不一样会把后面的填在slow的位置
            res[slow] = res[fast]
            
            # 如果发现和前一个一样，就退一格指针
            if slow > 0 and res[slow] == res[slow - 1]:
                slow -= 1
            else:
                slow += 1
            fast += 1
            
        return ''.join(res[0: slow])

这段代码实现了一个去除字符串中相邻重复字符的功能，具体方法是使用双指针来模拟栈的操作。以下是逐步解释：

1. 类定义 ：定义了一个名为 Solution 的类，其中包含一个名为 removeDuplicates 的方法。

2. 方法参数 ：removeDuplicates 方法接受一个字符串 s 作为输入，返回去除相邻重复字符后的字符串。

3. 初始化：

   • 将字符串 s 转换为列表 res（因为字符串是不可变的）。
   • 定义两个指针 slow 和 fast，均初始化为 0。slow 指针用于将结果写入新位置，fast 用于遍历原字符串。
   • 计算字符串的长度 length。

4. 主循环 ：while fast < length:：

   • 将 res[fast] 的值复制到 res[slow]，这一步相当于将字符放到结果的位置。

5. 判断条件：

   • if slow > 0 and res[slow] == res[slow - 1]:：如果 slow 大于 0 且当前字符与前一个字符相同，说明找到了相邻重复字符。此时将 slow 指针向后退一位。

6. 指针移动：

   • 如果没有发现相邻重复，slow 加 1，表示成功放入一个新的字符。
   • fast 每次循环都加 1，以继续遍历字符串。

7. 返回结果 ：return ''.join(res[0: slow])：最后，将 res 列表从 0 到 slow 的部分合并成一个字符串并返回，得到去除相邻重复字符后的结果。

总体来说，这个方法通过双指针的方式，有效地处理了字符串中的相邻重复字符，具有较好的性能。

我们来详细分析一下输入为 abbaca 时代码的执行流程。

1. 初始化：

   • 输入字符串：s = "abbaca"。
   • 转换为列表：res = ['a', 'b', 'b', 'a', 'c', 'a']。
   • 初始化指针：slow = 0，fast = 0。
   • 字符串长度：length = 6。

2. 开始循环：

   • 第一次迭代 (fast = 0)：

     • res[slow] = res[fast]，res[0] = res[0]（a），无变化。
     • slow = 1，fast 加 1（fast = 1）。

   • 第二次迭代 (fast = 1)：

     • res[slow] = res[fast]，res[1] = res[1]（b），无变化。
     • slow = 2，fast 加 1（fast = 2）。

   • 第三次迭代 (fast = 2)：

     • res[slow] = res[fast]，res[2] = res[2]（b），无变化。
     • 检查相邻：res[2] == res[1]（b == b），相同，slow 向后退，slow = 1。
     • fast 加 1（fast = 3）。

   • 第四次迭代 (fast = 3)：

     • res[slow] = res[fast]，res[1] = res[3]（a），变为 ['a', 'a', 'b', 'a', 'c', 'a']。
     • 检查相邻：res[1] == res[0]（a == a），相同，slow 向后退，slow = 0。
     • fast 加 1（fast = 4）。

   • 第五次迭代 (fast = 4)：

     • res[slow] = res[fast]，res[0] = res[4]（c），变为 ['c', 'a', 'b', 'a', 'c', 'a']。
     • 检查相邻：没有相邻重复，slow 加 1，slow = 1。
     • fast 加 1（fast = 5）。

   • 第六次迭代 (fast = 5)：

     • res[slow] = res[fast]，res[1] = res[5]（a），变为 ['c', 'a', 'b', 'a', 'c', 'a']。
     • 检查相邻：res[1] == res[0]（a != c），不同，slow 加 1，slow = 2。
     • fast 加 1（fast = 6）。

3. 结束循环：

   • fast 达到 length，循环结束。

4. 返回结果：

   • 最后，返回 ''.join(res[0:slow])，也就是 res 的前 2 个元素 ['c', 'a']，结果为 "ca"。

最终的返回结果是 "ca"，成功去除了输入字符串 abbaca 中的相邻重复字符。