系列文章目录

---

卡码网–数组篇(二分法)

卡码网–数组篇(移除元素)

---

前言

代码随想录详情链接

---

977.有序数组的平方

力扣链接：https://leetcode.cn/problems/squares-of-a-sorted-array/description/

Step 1: 读题：

1. 非递减序列 就是后面的数>=前面的
2. 返回的数组也要按非递减序列，就是也要排序
3. 注意有负值，求平方的话，有0，则最小值应该为0

Step2 ：可以求绝对值，用绝对值排序，再平方

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int size = nums.size();
        vector<int> newnums(size);
        for (int i=0;i<size;i++)
        {
            nums[i]=abs(nums[i]);
        }
        sort(nums.begin(),nums.end());
        for(int j = 0;j<size;j++)
        {
            newnums[j]=nums[j]*nums[j];
        }
        return newnums;
    }
    
};

这里有几个注意的点：

1. vector newnums(size); 定义一个新的容器的时候，记得一定要给他大小。
2. 排序函数 sort(nums.begin(),nums.end())

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        size = len(nums)
        L = [0] *size
        for i in range(0,size):
            nums[i] = abs(nums[i])
            i = i+1
        nums.sort()
        for j in range(0,size):
            L[j] = nums[j]*nums[j]
            j = j+1
        return L
        

这里注意 ，python里面新建列表 L = [0] *size 要预先分配空间，还有sort函数和C++中不一样。

双指针法

具体思路就是，由于是非递减序列，然后又有负数，最小值最多为0.所以排在最外面的绝对值最大，即平方后值最大。所以可以从两端开始比较，将大的一方放入新数组的最外侧。

#include <vector>  
#include <algorithm>  
  
class Solution {  
public:  
    std::vector<int> sortedSquares(std::vector<int>& nums) {  
        std::vector<int> result(nums.size());   
        int left = 0, right = nums.size() - 1, index = nums.size() - 1;  
        while (left <= right) {  
            int leftSquare = nums[left] * nums[left];  
            int rightSquare = nums[right] * nums[right];  
            if (leftSquare > rightSquare) {  
                result[index] = leftSquare;  
                left++;  
            } else {  
                result[index] = rightSquare;  
                right--;  
            }  
            index--;  
        }  
        return result;  
    }  
};

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        size = len(nums)
        L = [0] *size
        left=0
        right = size-1
        index = size-1
      
        while(left<=right):
            leftsquare = nums[left]*nums[left]
            rightsquare = nums[right]*nums[right]
            if(leftsquare>rightsquare):
                L[index] = leftsquare
                left = left+1
            else:
                L[index] = rightsquare
                right = right -1
            index=index-1
        return L
          
        

这里要注意，left和right指针相遇时也要算到，不然会漏掉一个

时间复杂度为O(nlogn)