Day1-leetcode26、283

一、解题过程

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

（1）题目描述

题目链接如下：

力扣26. 删除有序数组中的重复项https://leetcode.cn/problems/remove-duplicates-from-sorted-array/description/

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

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

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

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

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

做题分析：

首先，第一个问题：什么是“原地算法“？

这是百度百科的解释：

在计算机科学中，一个原地算法（in-place algorithm）是一种使用小的，固定数量的额外之空间来转换资料的算法。当算法执行时，输入的资料通常会被要输出的部分覆盖掉。不是原地算法有时候称为非原地（not-in-place）或不得其所（out-of-place）。

​

我的理解：空间复杂度为O（1）的算法。（即不使用额外的数组空间）

第二个问题：用自己的话解释题意

给一个升序数组，我们需要删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

前提，不要使用额外的数组空间。

---

ok

开始思考解决方法

因为我们要的只有前k位元素。--- >那后面的空间对我们来说就很随意。

我们可以从开始扫描该数组，通过一个变量work_id记录第一个数字的下标。

通过for循环（以i为循环变量）向后面扫描，我们会遇到两种情况。

1、该数字和我记录的work_id所指的数值相等，那我们及继续向后扫。
2、该数字和我记录的work_id所指的数值不相等，那就说明：
[work_id,i）这个区间内数字一样，nums[i] 与nums[work_id]不一样。

那么针对于第二种情况，我们的处理方法就是把nums[i]的值赋给nums[work_id+1]；

因为work_id的位置应该放nums[work_id]，所以nums[work_id+1]就放nums[i]的数值。

以此类推。即可。

代码片段：

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

---

283.移动零

（1）题目描述

题目链接如下：

力扣283. 移动零https://leetcode.cn/problems/move-zeroes/description/

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

示例 2:

输入: nums = [0]
输出: [0]

提示:

• 1 <= nums.length <= 104

• -231 <= nums[i] <= 231 - 1

做题分析：

又是“原地算法”，好，不用解释了。

用自己的话解释题意：

把给定的数组中的0都扔末尾，其他数按原来的顺序放前面。不使用额外数组空间。

---

开始思考解决方法： 最开始思考，如果我们继续像上一题一样按照从前向后扫的方法，交换覆盖的算法的话。

我们会发现，欸，好像也能做，只要找到第一个0的位置，从那里开始向后扫描，

遇到不是0的数值就把该数值覆盖在当前的位置，并且记录的位置向后+1. 
遇到是0的数字，自动向后推进

当然最后我们还需要记录一下共有k个0，把后面的k个位置全部赋值为0即可。

但是

我在写的过程中发现

其实我们可以通过一个变量i_nums0来记录当前i位置之前有几个0.

有啥用呢？我们可以直接一步到位，把nums[i]的值赋给nums[i-i_nums0]，这样相比于第一种思路我们少了一个变量

所以这种方法的最终代码是这样的：

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        //覆盖法
        int i_nums0=0;//i位置前0的个数。
        for(int i=0;i<nums.size();i++){
            if(nums[i]==0)i_nums0++;
            else {
                nums[i-i_nums0]=nums[i];
            }
        }
        //此次循环结束后，i_nums0表示总共有多少个0
        for(int j=nums.size()-i_nums0;j<=nums.size()-1;j++)nums[j]=0;//覆盖后面的0的个数。
    }
};

此题我写完后发现官方题解是双指针做法：

这里也稍微讲解一下：

左右指针均从数组0位置开始

左指针指向当前已经处理好的序列的下一个位置，右指针指向待处理序列的头部。

为什么左指针要指向下一个位置呢？

只有这样才能满足：
1、刚开始循环未遇到0之前，保证左右指针的位置同步变化，交换即相当于没有交换
2、右指针数字非零时，右指针的数字和左指针指的0进行交换
3、右指针数字为零时，左指针此刻指的为0

右指针不断向右移动，每次右指针指向非零数，则将左右指针对应的数交换，同时左指针右移。

经过运算此数组具备以下性质：
左指针左边均为非零数；
右指针左边直到左指针处均为零。
因此每次交换，都是将左指针的零与右指针的非零数交换，且非零数的相对顺序并未改变。

代码如下（复制的官方题解）：

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n = nums.size(), left = 0, right = 0;
        while (right < n) {
            if (nums[right]) {
                swap(nums[left], nums[right]);
                left++;
            }
            right++;
        }
    }
};

作者：力扣官方题解
链接：https://leetcode.cn/problems/move-zeroes/solutions/489622/yi-dong-ling-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

二、总结及计划

今天的题目整体来说很水，写了两道题，不过写题解的过程真的很让人成长，不仅要把各种思路搞清楚，还要把脑子里想的写出来，更考验自己对知识的理解能力了。

都是原地算法的题。

写这个题解也是希望督促自己每天写题，也希望可以帮到大家。

OK！继续加油。