面试经典算法系列之双指针4 -- 删除有序数组中的重复项

于 2024-04-10 22:20:54 发布
阅读量1k 收藏 24
点赞数 15
分类专栏： 面试经典算法系列 文章标签： 算法 面试 leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44630255/article/details/137613555
版权

面试经典算法题4 – 删除有序数组中的重复项

LeetCode.26
公众号：阿Q技术站

问题描述

给你一个 非严格递增排列 的数组 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 已按 非严格递增 排列

思路

  1. 初始化双指针： 我们定义两个指针 slow 和 fast，初始时分别指向数组的第一个元素和第二个元素。
  2. 遍历数组： 我们使用 fast 指针来遍历整个数组，从第二个元素开始遍历。
  3. 比较元素： 对于每个 fast 指针指向的元素 nums[fast]，我们将其与 slow 指针指向的元素 nums[slow] 进行比较：
    • 如果它们不相等，表示遇到了一个新的唯一元素，我们将其移到 nums[slow+1] 的位置，并将 slow 向后移动一个位置。
    • 如果它们相等，表示当前元素是重复出现的，我们继续向后遍历，直到找到一个新的唯一元素。
  4. 返回结果： 最后返回 slow+1，即为去重后的数组长度。在遍历过程中，slow 指针始终指向数组中最后一个唯一元素的位置，所以数组中唯一元素的数量为 slow+1。

演示过程

这里根据示例2给大家演示一下过程。

  1. 初始化两个指针slow和fast，分别指向数组的第一个元素和第二个元素。

image-20240121150936212

  1. 使用fast指针遍历整个数组，如果nums[fast] == nums[slow]，继续向后遍历。

image-20240121151740126

  1. 如果nums[fast] != nums[slow]，将 slow 指针向后移动一位，然后将当前元素复制到 slow 指向的位置，fast继续向后遍历。

image-20240121152642890

  1. 如果nums[fast] == nums[slow]，继续向后遍历。

image-20240121152730678

  1. 如果nums[fast] == nums[slow]，继续向后遍历。

image-20240121153002058

  1. 如果nums[fast] != nums[slow]，将 slow 指针向后移动一位，然后将当前元素复制到 slow 指向的位置，fast继续向后遍历。

image-20240121153123507

  1. 如果nums[fast] == nums[slow]，继续向后遍历。

image-20240121153218748

  1. 如果nums[fast] != nums[slow]，将 slow 指针向后移动一位，然后将当前元素复制到 slow 指向的位置，fast继续向后遍历。

image-20240121153325026

  1. 如果nums[fast] == nums[slow]，继续向后遍历。

image-20240121153410615

  1. 如果nums[fast] != nums[slow]，将 slow 指针向后移动一位，然后将当前元素复制到 slow 指向的位置，fast继续向后遍历。

image-20240121153520952

此时fast指针不小于nums.size()，跳出循环，返回slow+1即为新长度，这个示例结果为4+1=5，nums=[0,1,2,3,4]。

参考代码

C++
#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if (nums.empty()) {
            return 0; // 如果数组为空，则直接返回 0
        }

        int slow = 0; // 慢指针指向数组中当前唯一元素的最后一个位置
        for (int fast = 1; fast < nums.size(); ++fast) {
            if (nums[fast] != nums[slow]) {
                // 如果当前元素与慢指针指向的元素不相同，则将当前元素移到慢指针的下一个位置
                nums[++slow] = nums[fast];
            }
            // 如果当前元素与慢指针指向的元素相同，则继续遍历数组
        }

        return slow + 1; // 返回唯一元素的数量
    }
};

int main() {
    Solution solution;
    vector<int> nums = {0, 0, 1, 1, 1, 2, 2, 3, 3, 4};

    int k = solution.removeDuplicates(nums);
    cout << "Output : " << k << ", nums = [";
    for (int i = 0; i < k; ++i) {
        cout << nums[i] << (i < k - 1 ? ", " : "");
    }
    cout << "]" << endl;

    return 0;
}
Java
import java.util.Arrays;

class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums.length == 0) {
            return 0; // 如果数组为空，则直接返回 0
        }

        int slow = 0; // 慢指针指向数组中当前唯一元素的最后一个位置
        for (int fast = 1; fast < nums.length; ++fast) {
            if (nums[fast] != nums[slow]) {
                // 如果当前元素与慢指针指向的元素不相同，则将当前元素移到慢指针的下一个位置
                nums[++slow] = nums[fast];
            }
            // 如果当前元素与慢指针指向的元素相同，则继续遍历数组
        }

        return slow + 1; // 返回唯一元素的数量
    }
}

public class Main {
    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] nums = {0, 0, 1, 1, 1, 2, 2, 3, 3, 4};

        int k = solution.removeDuplicates(nums);
        System.out.print("Output : " + k + ", nums = [");
        for (int i = 0; i < k; ++i) {
            System.out.print(nums[i] + (i < k - 1 ? ", " : ""));
        }
        System.out.println("]");
    }
}
Python
class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        if not nums:
            return 0  # 如果数组为空，则直接返回 0

        slow = 0  # 慢指针指向数组中当前唯一元素的最后一个位置
        for fast in range(1, len(nums)):
            if nums[fast] != nums[slow]:
                # 如果当前元素与慢指针指向的元素不相同，则将当前元素移到慢指针的下一个位置
                slow += 1
                nums[slow] = nums[fast]

        return slow + 1  # 返回唯一元素的数量

if __name__ == "__main__":
    solution = Solution()
    nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]

    k = solution.removeDuplicates(nums)
    print(f"Output: {k}, nums = {nums[:k]}")

再来看看这个题的变形。

删除有序数组中的重复项II

问题描述

给你一个有序数组 nums ，请你原地删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。

说明：

为什么返回数值是整数，但输出的答案是数组呢？

请注意，输入数组是以**「引用」**方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：

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

示例 2：

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

提示：

  • 1 <= nums.length <= 3 * 104
  • -104 <= nums[i] <= 104
  • nums 已按升序排列

思路

  1. 首先检查数组的长度是否小于等于2，如果是，则无需删除重复元素，直接返回数组的长度即可。
  2. 初始化慢指针 slow 为2，表示数组的前两个元素无需处理，因为它们可以直接保留。
  3. 从数组的第三个元素开始遍历，使用快指针 fast 指向当前要处理的元素。
  4. 对于每个 nums[fast]，我们需要判断它是否与 nums[slow - 2] 相同。如果相同，说明当前元素重复出现超过两次，不符合要求，我们不需要将它保留在数组中；如果不相同，说明当前元素可以保留在数组中，我们将其移到慢指针 slow 的位置，并将 slow 向后移动一位。
  5. 遍历完成后，slow 指向的位置即为新数组的长度，返回该长度即可。

演示过程

这里根据示例2给大家进行图解演示。

  1. 初始化两个指针slow和fast，都指向下标为2的位置。为什么要放到位置2呢？原因就是根据题目要求，如果数组长度不超过2，则无需删除重复元素。

image-20240121161653006

  1. 使用fast遍历数组，判断nums[fast]与nums[slow - 2]。如果nums[fast] != nums[slow - 2]，将当前元素复制到 slow 指向的位置，再将slow向后移动一位，fast继续向后遍历。

image-20240121163358504

  1. 如果nums[fast] != nums[slow - 2]，将当前元素复制到 slow 指向的位置，再将slow向后移动一位，fast继续向后遍历。

image-20240121163509057

  1. 如果nums[fast] == nums[slow - 2]，fast继续向后遍历。

image-20240121163701131

  1. 如果nums[fast] == nums[slow - 2]，fast继续向后遍历。

image-20240121163753226

  1. 如果nums[fast] != nums[slow - 2]，将当前元素复制到 slow 指向的位置，再将slow向后移动一位，fast继续向后遍历。

image-20240121163904082

  1. 如果nums[fast] != nums[slow - 2]，将当前元素复制到 slow 指向的位置，再将slow向后移动一位，fast继续向后遍历。

image-20240121164026135

  1. 如果nums[fast] != nums[slow - 2]，将当前元素复制到 slow 指向的位置，再将slow向后移动一位，fast继续向后遍历。

image-20240121164137062

此时fast指针不小于nums.size()，跳出循环，返回slow即为新长度，这个实例结果为7，nums=[0,0,1,1,2,2,3]。

参考代码

C++
#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if (nums.size() <= 2) {
            return nums.size(); // 如果数组长度不超过2，则无需删除重复元素
        }

        int slow = 2; // 慢指针指向当前可以存放元素的位置
        for (int fast = 2; fast < nums.size(); ++fast) {
            if (nums[fast] != nums[slow - 2]) {
                // 如果当前元素与慢指针指向的前两个元素不相同，则将当前元素移到慢指针的位置
                nums[slow++] = nums[fast];
            }
            // 如果当前元素与慢指针指向的前两个元素相同，则继续遍历数组
        }

        return slow; // 返回删除重复元素后数组的新长度
    }
};

int main() {
    Solution solution;
   
    vector<int> nums = {0, 0, 1, 1, 1, 1, 2, 3, 3};
    int len = solution.removeDuplicates(nums);
    cout << "Output: " << len << ", nums = [";
    for (int i = 0; i < len; ++i) {
        cout << nums[i] << (i < len - 1 ? ", " : "");
    }
    cout << "]" << endl;

    return 0;
}
Java
import java.util.Arrays;

class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums.length <= 2) {
            return nums.length; // 如果数组长度不超过2，则无需删除重复元素
        }

        int slow = 2; // 慢指针指向当前可以存放元素的位置
        for (int fast = 2; fast < nums.length; ++fast) {
            if (nums[fast] != nums[slow - 2]) {
                // 如果当前元素与慢指针指向的前两个元素不相同，则将当前元素移到慢指针的位置
                nums[slow++] = nums[fast];
            }
            // 如果当前元素与慢指针指向的前两个元素相同，则继续遍历数组
        }

        return slow; // 返回删除重复元素后数组的新长度
    }
}

public class Main {
    public static void main(String[] args) {
        Solution solution = new Solution();

        int[] nums = {0, 0, 1, 1, 1, 1, 2, 3, 3};
        int len = solution.removeDuplicates(nums);
        System.out.print("Output: " + len + ", nums = [");
        for (int i = 0; i < len; ++i) {
            System.out.print(nums[i] + (i < len - 1 ? ", " : ""));
        }
        System.out.println("]");
    }
}
Python
class Solution:
    def removeDuplicates(self, nums):
        if len(nums) <= 2:
            return len(nums)  # 如果数组长度不超过2，则无需删除重复元素

        slow = 2  # 慢指针指向当前可以存放元素的位置
        for fast in range(2, len(nums)):
            if nums[fast] != nums[slow - 2]:
                # 如果当前元素与慢指针指向的前两个元素不相同，则将当前元素移到慢指针的位置
                nums[slow] = nums[fast]
                slow += 1
            # 如果当前元素与慢指针指向的前两个元素相同，则继续遍历数组

        return slow  # 返回删除重复元素后数组的新长度

if __name__ == "__main__":
    solution = Solution()
    nums = [0, 0, 1, 1, 1, 1, 2, 3, 3]
    len_result = solution.removeDuplicates(nums)
    print(f"Output: {len_result}, nums = {nums[:len_result]}")
第一篇【数组去重-双指针操作】
weixin_44882124的博客
03-07 369
给定一个升序（降序）数组，要求把数组中的重复数值去掉 示例数组：[1 1 1 2 2 3 4 5 5 5 5 5 5 6 7 8 8 9 ] 利用双指针操作如下 首先确定指针初始位置 左指针 left=0，有指针 right=1 判断右指针与左指针所指向的值是否相等，不相等的话，右指针右移 当右指针所指向的值与左指针指向的值不相等时，取出左指针所指向的值 接着左指针变到右指针位置，同时右指针继续右移 这样，把取出的值保存后，就重复数值后的数组了 ...
java-leetcode面试题解双指针之第26题删除有序数组中的重复项.zip
03-25
其中，第26题“删除有序数组中的重复项”是双指针技术的经典应用之一。本篇文章将深入探讨这个题目以及相关的Java实现。 题目描述： 给定一个有序数组nums，其元素都是唯一的，但可能包含重复的元素。请你删除所有...
双指针：删除有序数组中的重复项
Necho的博客
06-30 1309
双指针法，顾名思义，就是需要定于两个“指针”（不同于C语言中的指针）。我们最常用的就是对撞指针（相反方向）和快慢指针（相同方向）两种方法。本文结合Leetcode例题讲解双指针法的快慢指针的算法思维和解法！.........
数组去重（双指针）
yangyangcome的博客
05-27 1013
题目描述 给定一个长度为 n 的数组 a，请你编写一个函数： int get_unique_count(int a[], int n); // 返回数组前n个数中的不同数的个数 输入格式 第一行包含一个整数 n。 第二行包含 n 个整数，表示数组 a。 输出格式 共一行，包含一个整数表示数组中不同数的个数。 数据范围 1≤n≤1000 输入样例： 5 1 1 2 4 5 输出样例： 4 解法： 双指针做法：使用指针k 和 i，指针i 不断向后移动，如果指针 i 所指向的值与指针k-1 所指向的值
双指针算法实现数组去重
weixin_45981887的博客
04-06 722
双指针实现数组去重但保留k个相同元素 题目链接：leetcode传送门 原题目是最多保留2个相同的元素，这里我们扩展一下，最多保留k个相同的元素。 思路： 一直数组是有序的，单调递增 我们可以先将前k个元素保留，因为前k个元素不管重不重复这是一定存在的。（数组下标从0开始，保留0~k-1所有元素） 然后用 i 从第k个开始向后遍历，用一个变量 j 从第一个元素开始遍历，如果第 i 个与 j 元素不相等，就把第 i 个元素赋值在k的位置，j++ ，i++ ， k++，否则 i 继续向后遍历，j 不变 Code
双指针-删除排序数组的重复项
jiqiren1994的博客
09-10 156
一、题目描述 给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成。 二、理解题意 删除重复出现的元素，使每个元素只出现一次返回移除后数组的新长度 双指针解法： 定义两个指针（索引）分别指向目标位和待移动元素位 • 初始目标位为0，待移动元素位为1 比较两个指针对应的数据 • 比较相等：目标位不变，待移动位加1 • 比较不等：目标位加1，待移动元素赋值到目标位；待移动位
c语言面试题之双指针两数之和-输入有序数组.zip
03-29
本面试题探讨的是如何利用双指针找到输入有序数组中的两个数，使得它们的和等于一个特定的目标值。这个问题在算法设计和数据结构的学习中具有重要意义，因为它涉及到数组的遍历、条件判断以及效率优化。 首先，我们...
python-leetcode面试题解之第26题删除有序数组中的重复项-python题解.zip
03-12
在本压缩包中，我们关注的是一个Python编程与算法面试相关的资源，具体是LeetCode面试题的第26题——“删除有序数组中的重复项”。LeetCode是一个热门的在线平台，它提供了各种编程题目，帮助程序员提升算法技能，...
java-leetcode面试题解双指针之第977题有序数组的平方.zip
03-25
本资源“java_leetcode面试题解双指针之第977题有序数组的平方”聚焦于解决LeetCode上的第977题，这是一道与双指针技术和有序数组相关的算法问题。下面我们将深入探讨这个题目及其解决方案。 **题目描述：** ...
python-leetcode面试题解之第80题删除有序数组中的重复项II.zip
最新发布
04-23
本资源"python_leetcode面试题解之第80题删除有序数组中的重复项II"专注于解决LeetCode上的第80题，这是一道关于数据结构和算法的题目。下面我们将深入探讨这个问题及其解决方案。 ### 题目描述： 题目80题名为...
双指针算法，删除排序数组中的重复项
galaxyrt的博客
03-18 468
要求原地删除重复出现的元素，返回删除后数组的新长度，不能使用额外的数组空间 例如数组：arr=[0,1,2,2,3,3,4,] 利用双指针算法：定义指针 i (慢指针） j（快指针） 第一步：i j分别指向arr[0]和arr[1] 即：i->0; j->1 arr[i]!=arr[j] i++;j++ 第二步：i j分别指向arr[1]和arr[2] 即：i->1; j->2 arr[i]!=arr[j] i++;j++ 第三步：i j分别指向arr[2]和arr[3]
使用双(快慢)指针解决数组去重问题
Dpl0216的博客
03-02 1303
​ 双指针算法去重有一个前提，那就是数组已经是有序的状态。若数组并非有序，可以在使用本次算法之前先使用排序算法将数组转换成有序数组。本次算法为原地算法即额外空间复杂度为O(1)。
双指针实现数组去重（附详细图解）
MT_125的博客
04-22 1287
图解很详细哦 。
LeetCode7_数组双指针_有序数组元素去重、数组移除指定元素
xiaosi的博客
12-09 382
题目1-有序数组元素去重 给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。 不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 我的解答 思路 嵌套循环，外
java去除数组中重复的元素方法总结
12-16 566
/* * ArrayUnique.java * Version 1.0.0 * Created on 2017年12月16日 * Copyright ReYo.Cn */ package reyo.sdk.utils.test.array; /** * <B>创 建 人：</B>AdministratorReyoAut <BR&gt...
LeetCode 80. 删除排序数组中的重复项 II
Ailecccc的博客
11-19 220
LeetCode 80. 删除排序数组中的重复项 II 题目 给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素最多出现两次，返回移除后数组的新长度。 不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。 示例 1: 给定 nums = [1,1,1,2,2,3], 函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1...
算法练习：两指针之有序数组去重
憧憬，思考，奋斗，飞翔
07-02 2111
问题描述 给出一个有序数组，就地移除重复元素，保持每个元素只出现一次，并返回新数组的长度。   问题分析 这个比较简单，直接使用两个指针，一个在前，一个在后，扫描一遍数组即可。时间复杂度为O(n^2)。 比如数组A = { 1，1， 2， 3， 3 }，看下图，思想简单明了。       代码实现 #include using namespace std; //去除数组
leetcode 26、删除数组中的重复项（双指针）
ChanYipFan的博客
03-31 331
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。 不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。 示例 1: 给定数组 nums = [1,1,2], 函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。 你不需要考虑数组中超出新长度后面的元素。 示例 2: 给定 nums ...
数组篇——删除指定元素、删除重复元素(双指针法)[leetcode26、27、28、844]
2301_79376014的博客
02-10 450
一、暴力法，for循环遍历寻找需删除的元素，然后for循环用后面的元素向前覆盖。快慢双指针法,快指针指向新数组需要的元素，慢指针指向新数组元素的位置。时间复杂度：O(n^2)空间复杂度： O(1)空间复杂度： O(1)时间复杂度：O(n)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值