给你一个 升序排列 的数组 nums ，请你原地删除重复出现的元素，使每个元素 只出现一次 ， 返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。用python写

可以使用双指针的方法来解决这个问题。具体步骤如下：

1. 定义两个指针 i 和 j，初始位置都指向数组的第一个元素；
2. 从第二个元素开始，将 j 指针向后移动一位；
3. 如果 nums[j] 等于 nums[i]，则 j 指针继续向后移动一位；
4. 如果 nums[j] 不等于 nums[i]，则将 j 指针指向的元素覆盖到 i+1 的位置，并将 i 指针向后移动一位；
5. 重复步骤 3 和 4，直到 j 指针遍历完整个数组。

最后，新数组的长度就是 i+1。

Python 代码实现如下：

def removeDuplicates(nums):
if len(nums) == 0:
return 0
i = 0
for j in range(1, len(nums)):
if nums[j] != nums[i]:
i += 1
nums[i] = nums[j]
return i+1

nums = [1,1,2,2,3,4,4,5]
new_length = removeDuplicates(nums)
print(nums[:new_length]) # [1, 2, 3, 4, 5]

相关问题

给定一个升序排列的数组 nums，请原地删除重复出现的元素

如果要在原地删除重复出现的元素，可以使用双指针法。首先，初始化两个指针 i 和 j，其中 i 是慢指针，j 是快指针。然后，遍历数组，如果 nums[i] 等于 nums[j]，则递增 j，直到 nums[j] 不等于 nums[i]。接着，将 nums[j] 赋值给 nums[i+1]，并递增 i。重复上述过程，直到遍历完整个数组。

例如，给定数组 [0,0,1,1,1,2,2,3,3,4]，则原地删除重复出现的元素后，数组变为 [0,1,2,3,4]，并返回新数组的长度 5。

算法的时间复杂度为 O(n)，空间复杂度为 O(1)。

示例代码（使用 Python 语言）如下：

def removeDuplicates(nums):
    if not nums:
        return 0

    i = 0
    for j in range(1, len(nums)):
        if nums[i] != nums[j]:
            i += 1
            nums[i] = nums[j]

    return i + 1

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

### 回答1：
题目描述：

给定一个升序排列的数组 nums，要求原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持一致。

回答：

题目要求我们原地删除重复出现的元素，也就是不能使用额外的空间，只能在原数组上进行操作。我们可以使用双指针的方法来解决这个问题。

定义两个指针 i 和 j，初始时 i 指向数组的第一个元素，j 指向数组的第二个元素。如果 nums[i] == nums[j]，说明 j 指向的元素是重复的，我们就将 j 向后移动一位。如果 nums[i] != nums[j]，说明 j 指向的元素不是重复的，我们就将 i 向后移动一位，并将 nums[j] 的值赋给 nums[i]，然后将 j 向后移动一位。这样，当 j 遍历完整个数组时，i 指向的就是新数组的最后一个元素，新数组的长度就是 i+1。

代码如下：

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

### 回答2：
首先理解题目要求，是给定一个升序排列的数组，让我们在原地删除其中重复的元素，使得每个元素只出现一次，并返回删除后数组的新长度。需要注意的是，要保持原数组中元素的相对顺序不变。

解题思路是双指针法。我们设置两个指针，一个指针i从数组的第二个元素开始遍历，另一个指针j指向第一个元素。开始时，i和j都指向第一个不同的元素，然后遍历数组，如果i和j指向的元素相等，那么i向后移一位。如果i和j指向的元素不相等，就将i指向的元素复制到j+1的位置上，然后j向后移一位。重复这个过程，直到遍历到数组的末尾，这时候数组中的重复元素已经全部删除了。最后返回j+1表示删除重复元素后新数组的长度。

代码如下所示：

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        if not nums:
            return 0
        j = 0
        for i in range(1, len(nums)):
            if nums[i] != nums[j]:
                j += 1
                nums[j] = nums[i]
        return j + 1

时间复杂度是O(n)，空间复杂度是O(1)。这个方法非常简单易懂，而且在LeetCode中也具有很高的通过率。

### 回答3：
题目描述：

本题的目的是要求对一个已经按升序排列的数组进行去重复操作，保证每个元素仅出现一次，并且不会改变其他元素的排序和相对位置，并最终返回去重后的数组长度。

思路分析：

1. 首先考虑最简单的去重复办法：建立一个HashSet集合，然后遍历整个数组，把所有不重复的元素都放入HashSet集合中。每次遍历时，检查当前元素是否在集合中出现过，如果没有出现过，则将其加入集合中；否则，表示重复元素，直接跳过不做任何操作。

2. 但是题目要求不能用额外的空间，那么我们思考一下是否能够原地修改这个数组。由于数组已经是按照升序排列的了，所以，我们只需要维护前后两个指针（i和j），来扫描整个数组，检查是否有重复元素，如果有的话，我们将其删除即可。注意，题目中要求删除的是重复元素，而不是所有出现的元素，因此，在扫描的过程中，我们只需要让指针i记录下找到的不重复元素的位置，然后将其与后面的相同元素覆盖即可。

代码实现：

Java版

public int removeDuplicates(int[] nums) {
int n = nums.length;
if (n == 0) return 0;
int i = 0, j = 0;
while (j < n) {
if (nums[i] == nums[j]) {
j++;
} else {
nums[++i] = nums[j++];
}
}
return i + 1;
}

C++版

class Solution {
public:
int removeDuplicates(vector<int>& nums) {
int n = nums.size();
if (n == 0) return 0;
int i = 0, j = 0;
while (j < n) {
if (nums[i] == nums[j]) {
j++;
} else {
nums[++i] = nums[j++];
}
}
return i + 1;
}
};

Python3版

class Solution:
def removeDuplicates(self, nums: List[int]) -> int:
n = len(nums)
if n == 0: return 0
i, j = 0, 0
while j < n:
if nums[i] == nums[j]:
j += 1
else:
nums[i+1] = nums[j]
i += 1
j += 1
return i + 1

时间复杂度分析：

该算法的时间复杂度是O(n)，其中n为数组的长度。假设数组中有k个重复的元素，那么每个元素最多被比较一次，因此，时间复杂度是O(n)。由于题目中要求原地修改，所以空间复杂度是O(1)。