LeetCode 27 移除元素 LC977有序数组的平方

LeetCode 27 移除元素

题目跳转链接

####双指针法

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

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

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

思路： 双指针。 可以使用左右指针，也可以使用快慢指针。
使用快慢指针的代码↓

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

错误代码

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

Q:这样写哪里有问题？

A:
这个解法看起来是正确的，只要 val 出现在 nums 中，就将其它元素前移，然后将 nums 的长度改为 slow。这种解法的时间复杂度为 O(n)，因为需要遍历整个数组。

但是，在遇到 nums 中不存在 val 的情况时，这个解法会出现错误。在这种情况下，fast 将遍历整个数组，而 nums.resize(slow) 将导致 nums 的长度变为 0，因为 slow 的初始值为 0。

为了解决这个问题，可以将 nums.resize(slow) 移到 if(nums[fast]==val) 的外面，确保只有当 nums 中存在 val 时才执行 resize 操作。

(在if语句中，如果nums[fast]==val，就fast++，这样做的目的是为了跳过待删除元素。但是，如果nums[fast]!=val时，你也写了一个if-else语句，这个if-else语句中也有一个fast++，这样做是多余的。
因此，你可以将if语句中的fast++删除，这样就可以提高代码的效率。)

下面是修改后的代码：

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

Leetcode 977 有序数组的平方

题目跳转链接 -力扣

思路： 可以看到 肯定是两边的平方大。 比较好的处理方式是 ，先把两边平方最大的放入 结果数组的末尾，然后双指针向里走，最小平方的放到最前面(平方结果，从后往前放。)
但是有个问题 ， 什么时候是最小？ 双指针什么时候停？
（左边是i 右边是j K是从nums.size()-1开始的 ）

如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j]; 。

如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i]; 。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        int k = A.size() - 1;
        vector<int> result(A.size(), 0);
        for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
            if (A[i] * A[i] < A[j] * A[j])  {
                result[k--] = A[j] * A[j];
                j--;
            }
            else {
                result[k--] = A[i] * A[i];
                i++;
            }
        }
        return result;
    }
};
 
 

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums)
     {  int n=nums.size();
    
        int k=n-1;
        vector<int> result(n,0);
         for(int left=0,right=n-1;left<=right;)
         { 
             if(nums[left]*nums[left]>nums[right]*nums[right])
            {
 
            result[k--]=nums[left]*nums[left];
            left++;
 
            }
            else
            {
                result[k--]=nums[right]*nums[right];
                right--;
            }
 
         }
 
         return result;
    }
};