leetcode997

leetcode997

题目：给你一个按非递减顺序排序的整数数组nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

我的做法：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for (auto &i : nums){
            i = i * i;
        }
        int i = 0;
        while(i < nums.size() - 1 && nums[i + 1] <= nums[i]){
            i++;
        }

        #位置限制条件要加上，注意是<=

        vector<int> v;
        v.push_back(nums[i]);
        int n1 = i - 1;
        int n2 = i + 1;
        while (n1 >= 0 && n2 < nums.size()){
            if (nums[n1] < nums[n2]){
                v.push_back(nums[n1]);
                n1--;
            }
            else if (nums[n1] > nums[n2]){
                v.push_back(nums[n2]);
                n2++;
            }
            else{
                v.push_back(nums[n1]);
                v.push_back(nums[n2]);
                n1--;
                n2++;
            }
        }

        if (n1 >= 0){
            for (int i = n1; i >= 0; i--){
                v.push_back(nums[i]);
            }
        }
        if (n2 < nums.size()){
            for (int i = n2; i < nums.size(); i++){
                v.push_back(nums[i]);
            }
        }

        #单独处理剩余部分

        return v;
    }
};

缺点：

• 时间复杂度大
• 代码过于冗长
• 能想到中间往外扩，就该想到从两边往内缩

双指针法：

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;) {
            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;
    }
};

优点：

• 两边往里缩就不需要再单独处理剩余部分
• 代码清晰，简单明了
• 时间复杂度O(n)