【数组】leetcode977.有序数组的平方(C/C++/Java/Js)

1 题目

题源链接
给你一个按 非递减顺序 排序的整数数组 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) 的算法解决本问题

---

2 思路

2.1 自己的思路（双指针，类似归并思想）

由于nums数组中数字有正有负，所以定义一个pivot，将数组划分为负数部分和非负数部分。
先通过一轮数组遍历，找到pivot的位置，以及对数组中的元素求平方。
遍历结束后nums [ 0~pivot ] 放的是原数组中负数的平方，不难看出这一部分是降序，pivot所指为绝对值最小的负数，而nums [ (pivot+1) ~ max]放的是原数组中非负数的平方，这一部分是升序。
接下来采用类似归并排序中合并两个有序数组的算法思想。
由于结果数组需要升序，所以这里定义一个指针i指向pivot，指针j指向pivot+1，i递减遍历nums，j递增遍历nums，即合并两个有序的递增数组放到新数组中。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        //先将nums数组的负数部分和正数部分用pivot划分
        //然后对数组nums各元素求平方，之后利用两个指针对两个数组两两对比，按升序存入新数组C中
        int pivot = 0;//nums数组中划分正负数的枢纽，pivot所指为绝对值最小的负数，[0~pivot]为负
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] < 0)
                pivot = i;  //找pivot位置
            nums[i] *= nums[i];
        }//for结束此时num[0~pivot]为原数组负数部分的平方结果
        int i = pivot , j = pivot + 1;
        vector<int> result;
        while (i >= 0 && j < nums.size()){
            if (nums[i] <= nums[j]) 
                result.push_back (nums[i--]);
            else 
                result.push_back (nums[j++]);
        }//把剩余的元素拷贝进新数组，下面两个while只会执行一个
        while (i >= 0)
            result.push_back (nums[i--]);
        while (j < nums.size())
            result.push_back (nums[j++]);
        return result;
    }
};

2.2 双指针法（一遍遍历）

数组平方的最大值就在数组的两端，考虑双指针法，i指向起始位置，j指向终止位置。
由于结果数组要求升序，所以定义一个与nums大小相同的新数组result，让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];

---

3 代码

3.1 C版本

int* sortedSquares(int* nums, int numsSize, int* returnSize){
    //返回的数组大小就是原数组大小
    *returnSize = numsSize;
    //创建两个指针，right指向数组最后一位元素，left指向数组第一位元素
    int right = numsSize - 1;
    int left = 0;

    //最后要返回的结果数组
    int* ans = (int*)malloc(sizeof(int) * numsSize);
    int index;
    for(index = numsSize - 1; index >= 0; index--) {
        //左指针指向元素的平方
        int lSquare = nums[left] * nums[left];
        //右指针指向元素的平方
        int rSquare = nums[right] * nums[right];
        //若左指针指向元素平方比右指针指向元素平方大，将左指针指向元素平方放入结果数组。左指针右移一位
        if(lSquare > rSquare) {
            ans[index] = lSquare;
            left++;
        } 
        //若右指针指向元素平方比左指针指向元素平方大，将右指针指向元素平方放入结果数组。右指针左移一位
        else {
            ans[index] = rSquare;
            right--;
        }
    }
    //返回结果数组
    return ans;
}

---

3.2 C++版本

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

---

3.3 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;
    }
}

---

3.4 JavaScript版本

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var sortedSquares = function(nums) {
    let n = nums.length;
    let res = new Array(n).fill(0);
    let i = 0, j = n - 1, k = n - 1;
    while (i <= j) {
        let left = nums[i] * nums[i],
            right = nums[j] * nums[j];
        if (left < right) {
            res[k--] = right;
            j--;
        } else {
            res[k--] = left;
            i++;
        }
    }
    return res;
};

---

4 总结

对于该题，最直观的想法莫过于：每个数平方之后，采用O(nlogn)的排序算法排序，输出。
但是若想要时间复杂度达到O（n），还需另求他解。
这里我很自然的想到了归并排序的步骤，就是合并两个有序的子数组成一个有序的数组。也就是双指针法，只不过我一开始的想法需要先遍历一遍数组，找到分界线pivot的位置以及对每个元素求平方，之后再对两个子数组按从小到大的顺序两两比较存入新数组。
而思想二中直接从大到小比较，将较大者存入result中，只需遍历一遍。

---

By–Suki 2023/1/3
跨天那天阳了在休息就没有更，大家要好好照顾好身体呀。