学习参考：
problems/0977.有序数组的平方.md · programmercarl/leetcode-master（代码随想录出品） - Gitee.com
题目
给你一个按 非递减顺序 排序的整数数组 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]
解题思路
暴力法（Brute Force）
每个数平方之后，排个序:
public static int[] sortedSquares(int[] nums) {
if (nums == null || nums.length == 0) {
return new int[0];
}
int[] result = new int[nums.length];
for (int i = 0; i < nums.length; i++) {
result[i] = nums[i] * nums[i];
}
Arrays.sort(result);
return result;
}双指针法
如果数组nums中的所有数都是非负数，那么将每个数平方后，数组仍然保持升序；如果数组nums中的所有数都是负数，那么将每个数平方后，数组会保持降序。
这样一来，如果我们能够找到数组nums中负数与非负数的分界线，那么就可以用类似「归并排序」的方法了。
class Solution {
public int[] sortedSquares(int[] nums) {
//找到负数和非负数的分界点：
int n = nums.length;
int negative = -1;
for (int i = 0; i < n; ++i) {
if (nums[i] < 0) {
negative = i;
} else {
break;
}
/*
- 由于输入数组是按非递减顺序排序的，所以负数都在左边
- negative 记录最后一个负数的位置
- 遍历数组直到找到第一个非负数，此时 negative 就是最后一个负数的索引
*/
}
// 双指针合并：
int[] result = new int[n];
int index = 0, i = negative, j = negative + 1;
/*
- i 指向负数部分的最后一个数（从右往左遍历）
- j 指向非负数部分的第一个数（从左往右遍历）
- 通过比较两个指针指向的数的平方值，选择较小的放入结果数组
*/
while (i >= 0 || j < n) {
if (i < 0) { // 负数部分已经遍历完
result[index] = nums[j] * nums[j];
++j;
} else if (j == n) { // 非负数部分已经遍历完
result[index] = nums[i] * nums[i];
--i;
} else if (nums[i] * nums[i] < nums[j] * nums[j]) {
result[index] = nums[i] * nums[i];
--i;
} else {
result[index] = nums[j] * nums[j];
++j;
}
++index;
}
return result;
}
}双指针法优化
优化说明：
1. 去掉了寻找负数分界点的过程，直接使用双指针从两端向中间遍历
2. 从结果数组的末尾开始填充，保证平方值按非递减顺序排列
3. 将平方值计算结果存储在变量中，避免重复计算
4. 简化了条件判断逻辑，使代码更清晰易读
代码思路
数组其实是有序的， 只不过负数平方之后可能成为最大数了。
那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。
此时可以考虑双指针法了，left指向起始位置，right指向终止位置。
定义一个新数组result，和nums数组一样的大小，让index指向result数组终止位置。
如果leftSquare > rightSquare 那么result[index] = leftSquare; 。
如果leftSquare < rightSquare 那么result[index] = rightSquare; 。
public static int[] sortedSquares(int[] nums) {
if (nums == null || nums.length == 0) {
return new int[0];
}
int[] result = new int[nums.length];
int left = 0;
int right = nums.length - 1;
int index = nums.length - 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;
}
}整体运行代码：
import java.util.Arrays;
// LeetCode 977: 有序数组的平方
/**
* 题目描述：给你一个按 非递减顺序 排序的整数数组 nums[]
* 返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
*
* 示例：
* 输入：nums = [-4,-1,0,3,10]
* 输出：[0,1,9,16,100]
*/
public class SquareOfOrderedArray {
public static void main(String[] args) {
// 测试用例1: 包含负数、零和正数
int[] nums1 = {-4, -1, 0, 3, 10};
// 测试用例2: 包含较大的负数和正数
int[] nums2 = {-7, -3, 2, 3, 11};
// 使用三种不同方法进行测试
// 测试用例1的结果
int[] result1 = search1(nums1);
System.out.println("暴力解法结果1：" + Arrays.toString(result1));
int[] result2 = search2(nums1);
System.out.println("双指针法结果1：" + Arrays.toString(result2));
int[] result3 = search3(nums1);
System.out.println("优化双指针法结果1：" + Arrays.toString(result3));
// 测试用例2的结果
int[] result4 = search1(nums2);
System.out.println("暴力解法结果2：" + Arrays.toString(result4));
int[] result5 = search2(nums2);
System.out.println("双指针法结果2：" + Arrays.toString(result5));
int[] result6 = search3(nums2);
System.out.println("优化双指针法结果2：" + Arrays.toString(result6));
}
/**
* 方法一：暴力解法
* 思路：直接计算每个数的平方，然后排序
* 时间复杂度: O(nlogn) - 主要是排序的时间复杂度
* 空间复杂度: O(n) - 需要一个新数组存储结果
*
* @param nums 输入的有序数组
* @return 平方后的有序数组
*/
public static int[] search1(int[] nums) {
// 处理边界情况
if (nums == null || nums.length == 0) {
return new int[0];
}
// 计算每个数的平方
int[] result = new int[nums.length];
for (int i = 0; i < nums.length; i++) {
result[i] = nums[i] * nums[i];
}
// 对结果进行排序
Arrays.sort(result);
return result;
}
/**
* 方法二：双指针法
* 思路：利用数组有序的特点，找到负数和非负数的分界点，然后双指针合并
* 时间复杂度: O(n) - 只需要遍历一次数组
* 空间复杂度: O(1) - 不计算结果数组的空间
*
* @param nums 输入的有序数组
* @return 平方后的有序数组
*/
public static int[] search2(int[] nums) {
int n = nums.length;
// 找到最后一个负数的位置
int negative = -1;
for (int i = 0; i < n; ++i) {
if (nums[i] < 0) {
negative = i;
} else {
break;
}
}
int[] result = new int[n];
// i指向负数部分的最后一个元素，j指向非负数部分的第一个元素
int index = 0, i = negative, j = negative + 1;
while (i >= 0 || j < n) {
if (i < 0) { // 负数部分处理完毕
result[index] = nums[j] * nums[j];
++j;
} else if (j == n) { // 非负数部分处理完毕
result[index] = nums[i] * nums[i];
--i;
} else if (nums[i] * nums[i] < nums[j] * nums[j]) { // 比较两部分的平方值
result[index] = nums[i] * nums[i];
--i;
} else {
result[index] = nums[j] * nums[j];
++j;
}
++index;
}
return result;
}
/**
* 方法三：优化的双指针法
* 思路：从两端向中间遍历，直接比较两端的平方值
* 时间复杂度: O(n) - 只需要遍历一次数组
* 空间复杂度: O(n) - 需要一个新数组存储结果
*
* @param nums 输入的有序数组
* @return 平方后的有序数组
*/
public static int[] search3(int[] nums) {
// 处理边界情况
if (nums == null || nums.length == 0) {
return new int[0];
}
int[] result = new int[nums.length];
// 双指针分别指向数组两端
int left = 0;
int right = nums.length - 1;
// 从结果数组的末尾开始填充
int index = nums.length - 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;
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
