leetcode 80、leetcode 26、删除数组中的重复项

算法刷题笔记——day7

题目一

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

难度简单1935收藏分享切换为英文接收动态反馈

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

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

说明:

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

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

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

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

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[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 。不需要考虑数组中超出新长度后面的元素。

题解

public class removeDuplicatesClass {
    public static int removeDuplicates(int[] nums) {
        if (nums.length == 0) {
            return 0;
        }
        int i = 0;
        for (int j = 1; j < nums.length; j++) {
            if (nums[i]!=nums[j]){
                i++;
                nums[i]=nums[j];
            }
        }
        return i+1;
    }

    public static void main(String[] args) {
        int [] arr = {1,1,1,2,5,6,8,8,9};
        int len=removeDuplicates(arr);
        for (int i = 0; i < len; i++) {
            System.out.print(arr[i]+" ");
        }


    }
}

题目二

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

难度中等451收藏分享切换为英文关闭提醒反馈

给你一个有序数组 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 已按升序排列

解法一

public class removeDuplicates2Class {

        public static int removeDuplicates2(int[] nums){
            if(nums.length<=2){
                return nums.length;
            }
            int slow=2,fast=2;
            while (fast<nums.length){
                if (nums[slow-2]!=nums[fast]){
                    nums[slow]=nums[fast];
                    ++slow;
                }
                ++fast;
            }
            return slow;
        }


    public static void main(String[] args) {
        int [] arr={1,1,1,2,2,2,3,3,3,4};
        int len=removeDuplicates(arr);
        for (int i = 0; i < len; i++) {
            System.out.print(arr[i]+" ");
        }
    }

}

解法二

public class removeDuplicates2Class {
        public static int removeDuplicates(int[] nums) {
            int i=0,j;
            boolean isSame=true;
            for(j=1;j<nums.length;j++){
                if(nums[i]==nums[j]&& isSame){
                    isSame=false;
                    i++;
                    nums[i]=nums[j];
                    continue;
                }
                if(nums[i]!=nums[j]){
                    nums[i+1]=nums[j];
                    i++;
                    isSame=true;
                }

            }
            return i+1;
        }

    public static void main(String[] args) {
        int [] arr={1,1,1,2,2,2,3,3,3,4};
        int len=removeDuplicates(arr);
        for (int i = 0; i < len; i++) {
            System.out.print(arr[i]+" ");
        }
    }

}

我的错误解法

    public static int removeDuplicates3(int[] nums) {
        if (nums.length==0){
            return 0;
        }
        if (nums.length == 1) {
            return 1;
        }
        if (nums.length == 2) {
            return 2;

        }
        boolean isDifferent=true;
        int i=0;
        int temp = 0;
        for (int j=1;j<nums.length;j++){
            if (nums[i] == nums[j] && isDifferent){
                i++;
               if (i==1){
                   temp++;
               }else {
                   temp+=2;
               }
                isDifferent=false;
            }else if (nums[i] == nums[j]){

            }else {
                nums[temp+1]=nums[j];
                i=temp+1;
                isDifferent=true;
            }

        }
        return temp+2;
    }

思考

对比正确解法发现该题实际上是把后面不重复的数字赋值给前面的规定个数的后一位，不是发现一个数才赋值，而是之后每一位都要向前赋值，整体都要向前移动，比如，对于以下样例：

int [] arr={1,1,1,1,2,2,2,3,3,3,4};
有如下输出：
1 1 2 1 3 2 4 

可以看到，我只是把arr[4]（第一个2）的值赋给了arr[2]，arr[7]（第一个3）的值赋给了arr[4]，并记录下了正确的长度，才会出现此错解

拓展题（来自leetcode大佬宫水三叶L6）

通解

为了让解法更具有一般性，我们将原问题抽象为「保留 k 位」。

对于此类问题，我们应该进行如下考虑：

• 由于是保留 k 个相同数字，对于前 k 个数字，我们可以直接保留
• 对于后面的任意数字，能够保留的前提是：与当前写入的位置前面的第 k 个元素不相同

class Solution {
    public int removeDuplicates(int[] nums) {   
        return process(nums, 1);
    }
    int process(int[] nums, int k) {
        int u = 0; 
        for (int x : nums) {
            if (u < k || nums[u - k] != x) nums[u++] = x;
        }
        return u;
    }
}

• 时间复杂度：O(n)O(n)
• 空间复杂度：O(1)O(1)