leetcode刷题记录2021年3月22日

977. 有序数组的平方

这题比较简单，不过也是有不同的思路去做的，事件原因，我只写了两种思路，别的有时间再补充。

题目

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

示例：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

提示：
1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序

思路

一、我想的是用归并排序里的合并操作——将两个有序数组合并为一个，这里可以将正数和负数分别放在两个数组内，因为数组本身是有序的，所以这一步操作时O(n)的，之后比较两个数组的最小值，一个一个往结果数组里捡就行了，注意正数那边要反转一下。

二、还有一种比较快的是使用对撞指针，从两端开始找比较大的，放到结果数组里，最后把结果数组反转一下就行，注意最后一个值也放到数组里，总体上是思路一的优化版，省去了分成两个数组的功夫，能快1倍左右吧。

题解

思路一

#include<algorithm>
class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        vector<int> pos,nga;
        int n = A.size();
        for(int i=0;i<n;i++)
        {
            if(A[i]>=0) pos.push_back(A[i]);
            else nga.push_back(-1*A[i]);
        }
        reverse(pos.begin(),pos.end());
        vector<int> res;
        for(int i=0;i<n;i++)
        {
            if(pos.empty())
            {
                while(!nga.empty())
                {
                    int tmp = nga[nga.size()-1];
                    nga.pop_back();
                    res.push_back(tmp*tmp);
                }
                break;
            }
            if(nga.empty())
            {
                while(!pos.empty())
                {
                    int tmp = pos[pos.size()-1];
                    pos.pop_back();
                    res.push_back(tmp*tmp);
                }
                break;
            }
            int t1 = pos[pos.size()-1];
            int t2 = nga[nga.size()-1];
            if(t1<t2)
            {
                res.push_back(t1*t1);
                pos.pop_back();
            }else{
                res.push_back(t2*t2);
                nga.pop_back();
            }
        }
        return res;
    }
};

思路二

#include<algorithm>
class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        vector<int> res;
        int left = 0,right = A.size()-1;
        while(left<right)
        {
            int tl = A[left]*A[left];
            int tr = A[right]*A[right];
            if(tl>tr)
            {
                res.push_back(tl);
                left++;
            }else{
                res.push_back(tr);
                right--;
            }
        }
        res.push_back(A[right]*A[right]);
        reverse(res.begin(),res.end());
        return res;
    }
};