题目
给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
示例 2：
输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]
提示：
1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序
进阶：
请你设计时间复杂度为 O(n) 的算法解决本问题
思路
暴力排序
最直观的感觉，每个数平方之后，排个序。
此时时间复杂度为O(n + nlog n)
代码如下：
JavaScript
/**
* @param {number[]} nums
* @return {number[]}
*/
var sortedSquares = function(nums) {
const squared = nums.map(num => num * num);
const result = squared.sort((a,b) => a - b);
return result;
};
Java
class Solution {
public int[] sortedSquares(int[] nums) {
for (int i = 0; i < nums.length; i++) {
nums[i] = nums[i] * nums[i];
}
Arrays.sort(nums);
return nums;
}
}
双指针法
观察数据，其实会发现一个规律：数组排序时，哪怕负数在前边，但是平方的话，肯定不在中间，在数组的两边，所以可以考虑使用双指针法，i指向起始位置，j直接终止位置。
定义一个新数组，和A数组一样大小，让k指向result数组终止位置。
如果 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]
此时时间复杂度为O（n）
代码如下：
JavaScript
/**
* @param {number[]} nums
* @return {number[]}
*/
var sortedSquares = function(nums) {
let numLength = nums.length;
let result = new Array(numLength).fill(0);
let i = 0;
let j = numLength - 1;
let k = numLength - 1;
while (i <= j) {
let left = nums[i] * nums[i];
let right = nums[j] * nums[j];
if (left < right) {
result[k--] = right;
j--;
} else {
result[k--] = left;
i++;
}
}
return result;
};
Java
class Solution {
public int[] sortedSquares(int[] nums) {
int right = nums.length - 1;
int left = 0;
int[] result = new int[nums.length];
int index = result.length - 1;
while(left <= right) {
if (nums[left] * nums[left] > nums[right] * nums[right]) {
result[index--] = nums[left] * nums[left];
++left;
} else {
result[index--] = nums[right] * nums[right];
--right;
}
}
return result;
}
}
在leetcode提交上的效率
看提交记录图，发现一个很有意思的现象：
- JavaScript无论用哪种思路，差别都不大
- Java用更好的思路，提升很明显
结论：前端就老老实实写页面，不要做数据处理了
