力扣刷题——移动元素

力扣中关于移动元素的算法题。

1. leetcode——26题，移动元素。

这道题看到之后有两种思路。
1、第一种思路其实很简单，就是遍历数组中的元素，将其与目标值进行比较看是否相等，若相等的话，我们可以通过c++中的erase()函数对其进行删除。

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

2、第二种方法是我们可以对原数组进行覆盖（说成覆盖不知道对不对，哈哈）

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

2. leetcode——27题，删除排序数组中的重复项。

方案一：对数组元素进行遍历，删除重复的元素。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) 
    {
        if(nums.empty()) return 0; //这里要注意
        for(int i=1;i<nums.size();i++)
        {
            if(nums[i]==nums[i-1])
            {
                nums.erase(nums.begin()+i);
                i--;
            }
        }
        return nums.size();
    }
};

方案二：使用快慢指针法。慢指针slow_index是已经更新后数组的指针， 快指针fast_index遍历原始数组，判断要不要某个元素。

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

3. leetcode——80题，删除排序数组中的重复项Ⅱ。

第一种做法：首先我们要清楚，数组中的元素最多只能出现2次，需要把多余重复的元素给删除，所以我们可以让数组中的第3个元素与数组的第1个元素进行比较，如果相同的话，把第三个元素删除，此时数组的长度会减1，然后在让新的第三个元素与第一个元素进行比较。

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

第二种做法：快慢指针，由于是排序好的数组，所以快慢指针法可以使用。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if(n <= 2)
        {
            return n;
        }
        int slow_index=1;
        for(int fast_index=2;fast_index<nums.size();fast_index++)
        {
            if(nums[fast_index]!=nums[slow_index-1])
            {
                nums[++slow_index]=nums[fast_index];

            }
        }
        return slow_index+1;
    }
};

4. leetcode——283题，移动零。

第一种方案：
这道题的思路很简单，主要分为两部分。
1、首先遍历原数组，将数组中的非零元素统统赋值给nums[k],k的值记录了非零元素的个数。
2、需要第二次遍历数组，将零元素赋值给数组的最后面。

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n=nums.size();
        int k=0;
        for(int i=0;i<n;i++)
        {
            if(nums[i]!=0)
            {
                nums[k]=nums[i];
                k++;
            }
        }

        for(int i=k;i<n;i++)
        {
            nums[i]=0;
        }
    }
};

第二种方案：一次遍历即可，把不等于零的元素全放在数组左边。

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n=nums.size();
        int j=0;
        for(int i=0;i<n;i++)
        {
            if(nums[i]!=0)
            {
                int temp=nums[i];
                nums[i]=nums[j];
                nums[j++]=temp;
            }
        }
    }
};

这时我们可以在进一步对这个算法进行优化，假如所给的数组全为正数时，方案二仍需要对数组的元素进行交替赋值。

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n=nums.size();
        int j=0;
        for(int i=0;i<n;i++)
        {
            if(nums[i]!=0)
            {
                int temp=nums[i];
                nums[i]=nums[j];
                nums[j++]=temp;
            }
        }
    }
};