LeetCode算法实战 - - - 双指针与移除元素、快慢指针与删除有序数组中的重复项

第一题 - - - 移除元素
- 方法一 - - - 双重循环
- 方法二 - - - 双指针
- 方法三 - - - 相向双指针（面对面移动）
第二题 - - - 删除有序数组中的重复项
- 方法一 - - - 快慢指针
- 方法二 - - - 改进方法一
总结

💻作者简介：曾与你一样迷茫，现以经验助你入门数据结构。
💡个人主页：@笑口常开xpr 的个人主页
📚系列专栏：硬核数据结构与算法
✨代码趣语：恰当的数据视图实际上就决定了程序的结构。
💪代码千行，始于坚持，每日敲码，进阶编程之路。
📦gitee 链接：gitee

在这里插入图片描述

在数据结构的世界里，每一种设计都可能孕育出惊人的效率变革。你是否深思过，一组精心组织的数据究竟能创造怎样的奇迹？每一次挖掘底层原理，都是与计算机智慧的巅峰对话；每一次剖析存储模式，都在破解数据世界的终极密码。准备好迎接这场盛宴了吗？让我们一同探寻双指针的无尽奥秘，见证它如何重塑数字时代的运行法则！

第一题 - - - 移除元素

移除元素

描述：给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：
1、更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
2、返回 k。

示例 1：
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2,,]
解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
示例 2：
输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3,,,_]
解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。

注意这五个元素可以任意顺序返回。

提示：
0 <= nums.length <= 100
0 <= nums[i] <= 50
0 <= val <= 100

方法一 - - - 双重循环

思路分析

题目要求去除一组数中的重复元素，并且题目强调 nums 的其余元素和 nums 的大小并不重要。

可以通过双重循环遍历数组，当发现目标值时，将其后的所有元素依次前移一位，从而覆盖掉目标值元素。（类似顺序表中的头插）这样做的目的是在原数组上直接进行元素移除操作，不使用额外的存储空间，所以空间复杂度是 O(1)，时间复杂度是 O(N^2)。

温馨提示：读者们，先自己写代码，这是提升编程能力的好机会。若未达要求，别气馁，参考下文解释会有新收获。

下面展示代码示例。

int removeElement(int* nums, int numsSize, int val) 
{
    int i = 0;
    int count = 0;
    int temp1 = numsSize;
    while (i < temp1) 
    {
        if (nums[i] == val) 
        {
            int temp = i;
            while (temp < numsSize - 1) 
            {
                nums[temp] = nums[temp + 1];
                temp++;
            }
            count++;
            temp1--;
        }
        else 
        {
            i++;
        }
    }
    return numsSize - count;
}

注意

网站上刷题分为 IO 型和接口型，IO 型是使用 scanf 得到输入，结果使用 printf，并且要写出完整程序。接口型是结果通过返回值返回，只写实现的函数，是一部分程序。在 LeetCode 上刷题几乎都是接口型，调试起来比较麻烦，牛客网中有 IO 型和接口型。

以数组元素为 3,2,2,3,1,2,4,2 val 为 2 进行动画演示。

在这里插入图片描述

方法二 - - - 双指针

双指针

双指针是一种常用的算法技巧，利用它们之间的相对移动来高效地解决问题，核心思想是将遍历数组和原地修改分离，通过一次遍历完成元素筛选和数组重构，通过指针的位置关系快速定位目标元素或区间。时间复杂度优化至 O(n)。

同向双指针（快慢双指针）

同向即同一方向，两个指针朝同一方向移动，速度可能不同（快指针步长更大，慢指针步长较小）。

思路分析

题目要求删除数组中等于 val 的元素，因此 输出数组的长度一定小于等于输入数组的长度，我们可以 把输出的数组直接写在输入数组上。使用快指针 right 指向当前将要处理的元素，慢指针 left 指向下一个将要赋值的位置。

如果快指针指向的元素不等于 val，它一定是输出数组的一个元素，我们就将快指针指向的元素复制到慢指针位置，然后将快慢指针同时右移；

如果快指针指向的元素等于 val，它不能在输出数组里，此时左指针不动，右指针右移一位。

这里以示例 1 为例进行演示：

在这里插入图片描述

温馨提示：读者们，先自己写代码，这是提升编程能力的好机会。若未达要求，别气馁，参考下文解释会有新收获。

下面展示代码示例。

int removeElement(int* nums, int numsSize, int val) 
{
    int left = 0;
    for (int right = 0; right < numsSize; right++) 
    {
        if (nums[right] != val) 
        {
            nums[left] = nums[right];
            left++;
        }
    }
    return left;
}

在这里插入图片描述

时间复杂度：O(N)
空间复杂度：O(1)

方法三 - - - 相向双指针（面对面移动）

特点

两个指针分别从数组的两端出发，相向移动。

思路分析

设左指针位于数组的首位，右指针位于数组的末尾，向中间移动遍历该序列。如果左指针 left 指向的元素等于 val，此时将右指针 right 指向的元素复制到左指针 left 的位置，然后右指针 right 左移一位。如果赋值过来的元素恰好也等于 val，继续把右指针 right 指向的元素的值赋值过来（左指针 left 指向的等于 val 的元素的位置继续被覆盖），直到左指针指向的元素的值不等于 val 为止。当左指针 left 和右指针 right 重合的时候，左右指针遍历完数组中所有的元素。

这里以示例 1 为例进行演示：

在这里插入图片描述

温馨提示：读者们，先自己写代码，这是提升编程能力的好机会。若未达要求，别气馁，参考下文解释会有新收获。

下面展示代码示例。

int removeElement(int* nums, int numsSize, int val)
{
    int left = 0, right = numsSize;
    while (left < right) 
    {
        if (nums[left] == val) 
        {
            nums[left] = nums[right - 1];
            right--;
        } 
        else 
        {
            left++;
        }
    }
    return left;
}

时间复杂度：O(N)
空间复杂度：O(1)

第二题 - - - 删除有序数组中的重复项

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

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

示例 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。不需要考虑数组中超出新长度后面的元素。

方法一 - - - 快慢指针

思路分析：题目要求去除数组中的重复元素，并且题目强调使数组的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。可以使用双指针的快慢指针求解这个问题，慢指针指向当前唯一元素，快指针遍历数组，发现不同元素时更新慢指针。

温馨提示：读者们，先自己写代码，这是提升编程能力的好机会。若未达要求，别气馁，参考下文解释会有新收获。

下面展示代码示例。

int removeDuplicates(int* nums, int numsSize) 
{
    int left = 0;         //慢指针:指向当前无重复数组的最后位置
    int right = left + 1;        //快指针:从第二个元素开始遍历
    while(right < numsSize)      //遍历整个数组
    {
        if(nums[left] == nums[right])
        {
            right++;             //遇到重复元素，右移快指针
        }
        else
        {
            left++;              //找到新元素，更新慢指针位置
            nums[left] = nums[right]; //将新元素复制到慢指针位置
        }
    }
    return left + 1;  //返回无重复数组的长度（加上第1个元素）
}

空间复杂度是 O(1)
时间复杂度是 O(N)

方法二 - - - 改进方法一

相较于方法 1，方法 2 对方法 1 进行了改进，改进如下：

边界条件处理：
增加了 numsSize == 0 的判断，避免空数组导致的未定义行为。
指针初始化优化：
left 和 right 均初始化为 1，因为第一个元素（索引 0）天然无需处理。
比较逻辑简化：
通过比较 nums[right-1] 和 nums[right]，直接判断当前元素是否与前一个重复。当发现不重复元素时，直接赋值到 left 位置，并递增 left。

温馨提示：读者们，先自己写代码，这是提升编程能力的好机会。若未达要求，别气馁，参考下文解释会有新收获。

下面展示代码示例。

int removeDuplicates(int* nums, int numsSize) 
{
    if(numsSize == 0)           //处理空数组的边界情况
    {
        return 0;
    }
    int left = 1;               //慢指针:从第二个位置开始写入
    int right = 1;              //快指针:从第二个位置开始遍历
    while(right < numsSize)     //遍历整个数组
    {
        if(nums[right-1] != nums[right]) //当前元素与前一个不同
        {
            nums[left] = nums[right];   //将新元素写入left位置
            left++;                     //移动left指针
        }
        right++;                    //无论如何都移动right指针
    }
    return left;                     //返回无重复数组的长度
}

时间复杂度是 O(N)
空间复杂度是 O(1)

在这里插入图片描述

总结

至此，关于双指针的探索暂告一段落，但你的编程征程才刚刚启航。编写代码是与计算机逻辑深度对话，过程中虽会在结构设计、算法实现的困境里挣扎，但这些磨砺加深了对代码逻辑和数据组织的理解。愿你合上电脑后，灵感不断，在数据结构的世界里持续深耕，书写属于自己的编程传奇，下一次开启，定有全新的精彩等待。小编期待重逢，盼下次阅读时见证你们更大的进步，共赴代码之约！