26、leetcode之删除排序数组中的重复项

题目：

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

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。

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

leetcode题目链接：https://leetcode.cn/leetbook/read/top-interview-questions-easy/x2gy9m/

示例 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 已按 升序 排列

个人解答（Java）：

         因为本题要求了不能使用额外空间，所以不能创建一个新的数组将原数组不重复元素复制到新的数组实现重复元素的删除。但本题没有对时间复杂度进行要求，所以简单的方法就是使用循环嵌套来实现。

        第一个for循环是先从0开始进行遍历，然后在循环内从开始循环的后一个位置继续循环，这个第二次循环是为了找出相等元素，如果有相等元素则开始第三次循环（将后面的数组元素向前移动替代相等元素的位置）。同时在第二次循环的时候记下相同元素的个数，以便得出数组中不同元素的个数。

参考代码：

import java.util.Scanner;

public class RemoveDuplicates {
    public static int removeDuplicates(int[] nums) {
    	int count=0;
    	for(int i=0;i<nums.length-count;i++) {
    		int a=nums[i];
    		for(int j=i+1;j<nums.length-count;j++) {
    			if(nums[j]==a) {
    				count++;
    				for(int k=j;k<nums.length-1;k++) {
    	    			nums[k]=nums[k+1];
    	    		}
    				j--;
    			}
    			
    		}
    	}
    	return nums.length-count;
    }
	public static void main(String []args) {
		System.out.println("请输入几个数并用逗号隔开：");
		Scanner sc = new Scanner(System.in);
		String str = sc.next().toString();
		String[] arr  = str.split(",");
		int[] nums = new int[arr.length];
		for(int j = 0; j<nums.length;j++) {
		   nums[j] = Integer.parseInt(arr[j]);
		}
		int length=removeDuplicates(nums);
		System.out.print(length);
		System.out.print(" ,nums=[");
		for(int j = 0; j<length;j++) {
			if(j==length-1) {
				System.out.print(nums[j]+"]");
			}
			else System.out.print(nums[j]+",");
		}
	}
}

         总的来说，这个算法的时间复杂度太高，不推荐。于是我又去网上查找了一些效率比较高的解决方案。

优质解答1（Java）：

leetcode网页中，题目下面的第一条讨论（作者力扣用户名：数据结构和算法）中提到的答案就非常优质，获得了很多人的点赞和认同。

直到看到了这位大佬的解析，我才发现数组升序是非常重要的参考因素。不过在我知道这个信息后，我也尝试了自己独立思考，找出相对于上面的解答更高效的解答，但还是没有思绪。然后我就认真阅读了这位大佬的答案。

他的关键词是双指针，实质上是用两个指针把数组中不重复的元素移动到数组最前面，的确非常高效，时间复杂度只有O(n)。

右指针的作用是扫描整个数组，所以无论任何情况它都要向右移动，所以将右指针写在了for循环的条件里。左指针的初始值是0，右指针的初始值是1，这样才可以开始比较。如果左指针和右指针指向的值一样，说明右指针上面的是重复值，就可以直接跳过，体现在代码上，就是，不做任何操作不处理，不过右指针还是会在for循环的运行下向右移。如果两个指针对应的值不一样，就说明右指针上的值需要被记录，这时候需要先把左指针加1，这样左指针就指向了一个新的位置，就可以存放右指针的值。

总之，就是右指针扫描，左指针存值。

    public static int removeDuplicates(int[] nums) {
        //边界条件判断
        if (nums == null || nums.length == 0)
        	return 0;
        int left = 0;
        for (int right = 1; right < nums.length; right++)
            if (nums[left] != nums[right]){
            	nums[++left] = nums[right];
            }
        return ++left;
    }

优质解答2（Java）：

下面这个是leetcode官方给的解答（有视频讲解）：

方法一：双指针
这道题目的要求是：对给定的有序数组nums 删除重复元素，在删除重复元素之后，每个元素只出现一次，并返回新的长度，上述操作必须通过原地修改数组的方法，使用 O(1)的空间复杂度完成。

由于给定的数组nums 是有序的，因此对于任意 i<j，如果nums[i]=nums[j]，则对任意i≤k≤j，必有 nums[i]=nums[k]=nums[j]，即相等的元素在数组中的下标一定是连续的。利用数组有序的特点，可以通过双指针的方法删除重复元素。

如果数组 nums 的长度为 00，则数组不包含任何元素，因此返回 0。

当数组 nums 的长度大于 0 时，数组中至少包含一个元素，在删除重复元素之后也至少剩下一个元素，因此nums[0] 保持原状即可，从下标 1 开始删除重复元素。

定义两个指针fast 和 slow 分别为快指针和慢指针，快指针表示遍历数组到达的下标位置，慢指针表示下一个不同元素要填入的下标位置，初始时两个指针都指向下标 1。

假设数组nums 的长度为 n。将快指针 fast 依次遍历从 1 到 n−1 的每个位置，对于每个位置，如果 nums[fast] 不等于nums[fast−1]，说明nums[fast] 和之前的元素都不同，因此将 nums[fast] 的值复制到nums[slow]，然后将 slow 的值加 1，即指向下一个位置。

遍历结束之后，从 nums[0] 到nums[slow−1] 的每个元素都不相同且包含原数组中的每个不同的元素，因此新的长度即为slow，返回slow 即可。
链接：https://leetcode.cn/problems/remove-duplicates-from-sorted-array/solution/shan-chu-pai-xu-shu-zu-zhong-de-zhong-fu-tudo/

public int removeDuplicates(int[] nums) {
        int n = nums.length;
        if (n == 0) {
            return 0;
        }
        int fast = 1, slow = 1;
        while (fast < n) {
            if (nums[fast] != nums[fast - 1]) {
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
        return slow;
    }

python版解答：

 def removeDuplicates(self, nums: List[int]) -> int:
        if not nums:
            return 0
        
        n = len(nums)
        fast = slow = 1
        while fast < n:
            if nums[fast] != nums[fast - 1]:
                nums[slow] = nums[fast]
                slow += 1
            fast += 1
        
        return slow