977.有序数组的平方（力扣LeetCode）

977.有序数组的平方

题目描述

给你一个按 非递减顺序 排序的整数数组 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 <= 10⁴
• -10⁴ <= nums[i] <= 10⁴
• nums 已按 非递减顺序 排序

快速排序

对快排算法不了解的可以看我这篇博客：快速排序算法

class Solution {
public:
    // sortedSquares 函数接收一个按非递减顺序排列的整数数组，并返回一个新的非递减排序的平方数组
    vector<int> sortedSquares(vector<int>& nums) {
        // 遍历输入的数组，计算每个元素的平方
        for(int i = 0; i < nums.size(); i++) 
            nums[i] *= nums[i]; // 将元素自身乘以自身，实现平方
        // 调用快速排序函数对平方后的数组进行非递减排序
        quick_sort(nums, 0, nums.size() - 1);
        // 返回排序后的数组
        return nums;
    }

private:
    // quick_sort 函数实现快速排序算法
    void quick_sort(vector<int>& nums, int l, int r) {
        // 如果子数组长度为0或负，则不需要排序，直接返回
        if(l >= r) return;

        // 初始化双指针和中间值
        int i = l - 1, j = r + 1, x = nums[(l + r) >> 1];
        while(i < j) {
            // 从左向右找第一个大于或等于x的数
            do i++; while(nums[i] < x);
            // 从右向左找第一个小于或等于x的数
            do j--; while(nums[j] > x);
            // 如果满足条件，交换两个数
            if(i < j) swap(nums[i], nums[j]);
        }

        // 递归排序 x 左边的部分
        quick_sort(nums, l, j);
        // 递归排序 x 右边的部分
        quick_sort(nums, j + 1, r);
    }
};

归并排序

对归并排序算法不了解的可以看我这篇博客：归并排序算法

class Solution {
public:
    // sortedSquares函数接收一个非递减的整数数组nums，并返回每个数平方后同样非递减排序的新数组
    vector<int> sortedSquares(vector<int>& nums) {
        // 遍历输入数组，计算每个元素的平方
        for(int i = 0; i < nums.size(); i++) 
            nums[i] *= nums[i];
        // 对平方后的数组进行归并排序
        merge_sort(nums, 0, nums.size() - 1);
        // 返回排序后的数组
        return nums;
    }

private:
    // merge_sort函数实现归并排序算法
    void merge_sort(vector<int>& nums, int l, int r) {
        // 如果子数组的长度为0或者负数，则不需要排序
        if(l >= r) return;

        // 计算数组的中点，用于分割数组
        int mid = (l + r) >> 1; // 等价于(l + r) / 2，但是位运算更快
        // 递归地对数组的前半部分进行排序
        merge_sort(nums, l, mid);
        // 递归地对数组的后半部分进行排序
        merge_sort(nums, mid + 1, r);

        // 使用两个游标i和j来遍历两个子数组
        int k = 0, i = l, j = mid + 1;
        // 创建一个临时数组用于存放排序后的结果
        vector<int> tmp(r - l + 1);
        // 合并两个已排序的子数组
        while(i <= mid && j <= r) {
            if(nums[i] <= nums[j]) tmp[k++] = nums[i++];
            else                   tmp[k++] = nums[j++];
        }

        // 如果有剩余的元素，将它们复制到临时数组中
        while(i <= mid) tmp[k++] = nums[i++];
        while(j <= r)   tmp[k++] = nums[j++];

        // 将排序后的临时数组复制回原数组
        for(i = l, j = 0; i <= r; i++, j++) nums[i] = tmp[j];
    }
};

双指针

  这道题目能够使用双指针方法的原因在于题目本身的特性。题目给出的数组 nums 是一个非递减排序的数组，这意味着数组中元素的绝对值从两端向中心递增。当需要得到每个元素平方后的数组并且也要求是非递减排序时，最大的难点在于负数的平方可能会变得比正数大，即 (-k)^2 ^> j²，其中 k 和 j 都是正数。

  为了解决这个问题，双指针技术非常有效：

  1.数组两端的元素平方值最大：由于原数组是非递减排序的，最大的元素平方值将出现在数组的两端。正数的最大值在数组的末尾，而负数的最大绝对值在数组的开头。

  2.双指针从两端向中心移动：一个指针指向开头（负数区域的最大绝对值），一个指针指向末尾（正数区域的最大值）。在每一步中，比较这两个指针指向元素的平方值，将较大的平方值放入答案数组的当前位置（从末尾开始填充），然后移动相应的指针（如果负数区域的平方大，则移动开头的指针，反之，移动末尾的指针）。

  无需额外的比较或排序：由于从两端开始并将最大值依次放入答案数组的末尾，我们无需进行额外的比较或排序操作，答案数组自然就是非递减排序的。

  此方法的有效性基于对原数组排序特性的充分利用，即利用了非递减排序的特点，以及负数平方后可能会大于正数的性质。通过双指针从两端向中心遍历和比较，可以有效地一次遍历就得到正确的排序结果，从而实现时间复杂度为 O(n) 的算法。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        // 初始化k为最后一个元素的索引，这是因为平方后的最大值将会放在这个位置
        int k = nums.size() - 1;
      
        int i , j ;
        // 初始化结果数组，大小与输入数组相同
        vector<int> z(nums.size());

        // 当i和j没有相遇时，进行循环
        //当 i > j 时，意味着两个指针相遇或者交叉，表示所有元素都已经遍历比较过一次，因此任务完成。
        //如果 i 和 j 相等，还有一个元素需要处理，它们平方后应该放在当前的 k 位置。如果 i 和 j 交叉了，说明所有元素都已经处理完毕。
        for(i = 0, j = nums.size() - 1; i <= j;) {
            // 比较i和j位置上元素的平方大小
            if(nums[i] * nums[i] > nums[j] * nums[j]) {
                // 如果i位置的元素平方更大，将其平方值放在结果数组的当前k位置
                z[k--] = nums[i] * nums[i];
                // 将i向后移动，以比较下一个元素
                i++;
            } else {
                // 如果j位置的元素平方更大或者相等，将其平方值放在结果数组的当前k位置
                z[k--] = nums[j] * nums[j];
                // 将j向前移动，以比较下一个元素
                j--;
            }
        }

        // 返回已经按非递减顺序排序的平方数组
        return z;
    }
};