【LeetCode刷题笔记】7.删除有序数组中的重复项（26）8.移动零（283）9.比较含退格的字符串(844)

最新推荐文章于 2025-12-19 16:34:09 发布

原创最新推荐文章于 2025-12-19 16:34:09 发布 · 700 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #笔记 #算法

LeetCode刷题笔记专栏收录该内容

8 篇文章

订阅专栏

文章讲述了使用双指针策略在数组去重和移动零操作中的应用，包括删除重复元素保持顺序、移动0的同时保持非零元素位置不变，以及处理含退格字符的字符串比较

7.删除有序数组中的重复项（26）

题目

给你一个 非严格递增排列 的数组 nums ，请你** 原地** 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持一致。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
返回 k 。

判题标准:

系统会用下面的代码来测试你的题解:

int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案

int k = removeDuplicates(nums); // 调用

assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i];
}

如果所有断言都通过，那么您的题解将被通过。

示例 1：

输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

提示：

1 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums 已按 非严格递增 排列

思路及题解

处理数组问题，按照惯例用双指针
这题数组元素的先后顺序不能变化，所以不考虑对撞指针，只能考虑快慢指针
由于数组非严格递增，因此重复元素的位置其实是知道的，就在每个不重复元素的后面
慢指针指向修改的元素，快指针逐个遍历元素直到越界
用val变量存储遇到的不重复元素，当快指针遍历到与val不同的元素时，慢指针对应的元素更改为快指针的值，同时更新val
最终返回慢指针的值+1，即为修改过的元素数目，即为新数组长度

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int slow = 0, fast = 0, val = nums[0];
        for (; fast < nums.size(); fast++) {
            if (nums[fast] != val) {
                slow++;
                nums[slow] = nums[fast];
                val = nums[slow];
            }
        }
        return slow + 1;
    }
};

优化：可以不用val变量存储不重复元素，因为val的作用是判断什么时候遇到了新的不重复元素，可以用 nums[fast -1] != nums[fast]作为判断条件

//优化的双指针算法
class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        int slow = 1, fast = 1;
        while (fast < n) {
            if (nums[fast - 1] != nums[fast]) {
                nums[slow] = nums[fast];
                slow++;
            }
            fast++;
        }
        return slow;
    }
};

8.移动零（283）

题目

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

示例 2:

输入: nums = [0]
输出: [0]

提示:

1 <= nums.length <= 104
-231 <= nums[i] <= 231 - 1

**进阶：**你能尽量减少完成的操作次数吗？

思路及题解

因为要保证处理前后的顺序，所以用快慢指针
慢指针找到待交换的 ‘0’，快指针找到要交换的非零数
慢指针要注意防止越界，越界了交换结束
当慢指针出现在快指针前面时，不进行交换，否则会把零交换到前面，把非零数交换到后面

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int slow = 0, fast = 0;
        for (; fast < nums.size(); fast++) {
            while (nums[slow] != 0) {
                slow++;
                if (slow >= nums.size())
                    return;
            }
            if (nums[fast] != 0 && slow < fast) {
                swap(nums[slow],nums[fast]);
            }
        }
    }
};

另一种快慢指针：慢指针指向已经处理好的序列的尾部，快指针指向待处理的序列头部
这样慢指针左边永远是已经处理好的序列，快指针左边的数字都是0，直到遇见快指针
这种写法可以减少判断的条件，代码更加简洁，但是需要交换的次数增多
如输入为nums =[1,2,3,4,5,0,0,1,2,3]时，这种写法前面的1,2,3,4,5都需要与其自身交换一次，而第一种写法却不用

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int slow = 0, fast = 0;
        while (fast < nums.size()) {
            if (nums[fast]) {
                swap(nums[slow], nums[fast]);
                slow++;
            }
            fast++;
        }
    }
};

9.比较含退格的字符串(844)

题目

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

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

示例 1：

输入：s = "ab#c", t = "ad#c"
输出：true
解释：s 和 t 都会变成 "ac"。

示例 2：

输入：s = "ab##", t = "c#d#"
输出：true
解释：s 和 t 都会变成 ""。

示例 3：

输入：s = "a#c", t = "b"
输出：false
解释：s 会变成 "c"，但 t 仍然是 "b"。

提示：

1 <= s.length, t.length <= 200
s 和 t 只含有小写字母以及字符 '#'

进阶：

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

思路及题解

双指针法，慢指针指向前一个元素，快指针指向后一个元素，如果后一个元素是 ‘#’ ，就把前一个元素和 ‘#’ 同时删除，再恢复快慢指针的位置，直到快指针越界为止
用到的库函数：erase、compare、[]（随机访问string）

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        //这里可以再简化，直接return
        s = func(s);
        t = func(t);
        if (s.compare(t))
            return false;
        else
            return true;
    }
    string func(string str) {
        int slow = 0, fast = 0;
        while (fast < str.size()) {
            //一开始，两个指针指向同一个元素
            //如果慢指针指向了'#'，说明前面没有要删除的元素，直接把这个'#'删掉
            while (str[slow] == '#') {//这里要用while而不是if，因为'#'可能连续出现
                str.erase(slow, 1);
                //删完之后进行一次越界判断
                if (fast >= str.size())
                    return str;
            }
            //快指针指向后一个元素
            fast++;
            if (str[fast] == '#') {
                //删除两个元素
                str.erase(slow, 2);
                //慢指针指向第一个元素的情况要分开讨论，否则慢指针会越界
                if (slow - 1 >= 0) {
                    slow--;
                    fast = slow;
                } else {
                    slow = 0;
                    fast = 0;
                }
            } else
                slow++;	//如果快指针不是指向'#'，两个指针同时向前
        }
        return str;
    }
};

这题用栈的解法更为简洁，如果下一个字符不为‘#’，则将让该元素进栈。如果下一个字符为’#'且栈不为空（前面有待删除的元素），则出栈，最后剩下的就是修改过的字符串

class Solution {
public:
    bool backspaceCompare(string s, string t) { return func(s) == func(t); }
    string func(string str) {
        string stack;
        for (char ch : str) {
            if (ch != '#')
                stack.push_back(ch);
            else if (!stack.empty())
                stack.pop_back();
        }
        return stack;
    }
};