力扣数组初始定义

花了一天把数组初始定义的题都做了，虽然题目的思想都是快慢指针，但是自己对快慢指针不熟练，都是用的遍历数组，记录删除次数调整遍历位置误差来做的。

第一题

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

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
    for(int i=0,j=0;i<nums.size();i++){
        if(nums[i-j]==0){
            nums.erase(nums.begin()+i-j);
            nums.push_back(0);
            j++;
        }
    }
    }
};

这是我思考许久之后的代码，直接删除，调整删除后的位置误差

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++;
        }
    }
};

这是双指针的思想，初步了解了快慢指针，慢指针是确认正确的地方，快指针是要遍历的进度。

第二题

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        for(int i=0,j=0;i<nums.size()+j;i++){
            if(nums[i-j]==val){
                nums.erase(nums.begin()+i-j);
                j++;
            }
        }
        return nums.size();
    }
};

这是我的代码，还是用的老方法，如果题目顺序不变的话还好，题目要求顺序可以变化，则双指针要做的事更少

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int left = 0, right = nums.size();
        while (left < right) {
            if (nums[left] == val) {
                nums[left] = nums[right - 1];
                right--;
            } else {
                left++;
            }
        }
        return left;
    }
};

双指针，一个从头遍历，另一个从尾遍历，从头遍历的遇到要删除的值，就把尾部的值变化过来，不过变过来的时候尾指针--但头指针不增加（为了判断移过来的值也是要删除的值），如果头指针不是要删除的值，头指针++。

第三题

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

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

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

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

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

    }
};

这道题第一次接触力扣的时候就写了，写了两个for遍历了两次，做的无用功非常多（因为那时候没接触过双指针）

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

这是后面自己优化的代码，刚开始的时候运行错误，因为刚开始return的是j，要确定j的值和数组长度的关系，应该是return ++j。看了官方答案，和自己差不多，就不贴了。

第四题

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

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

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int m=nums.size();
        for(int i=1,k=1,j=0;i<m;i++){   //i为要遍历的次数，也就是数组原本长度，k为单个数量
            if(nums[i-j]==nums[i-1-j]){
                if(k<2){    //单个数量小于2，只记录单个数量
                k++;
                }
                else {  //单个数量大于2
                    nums.erase(nums.begin()+i-j);   //删除
                    j++;                        //记录删除次数，调整误差
                }
            }   
                else{
                    k=1;
                }
        }
        return nums.size();
    }
};

这道题刚开始的时候想过双指针的方法，不过自己才疏学浅，写不出来，写出个大概之后总是有bug，调整不了误差，因为它每次是两个相同的元素，所以每次都有一个误差。这时候我就用了自己的老方法，直接把要删除的元素删掉，再调整误差。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if (n <= 2) {
            return n;
        }
        int slow = 2, fast = 2;
        while (fast < n) {
            if (nums[slow - 2] != nums[fast]) {
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
        return slow;
    }
};

这是官方双指针的代码，它调整了步长。