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 已按 非递减顺序 排序

进阶：请你设计时间复杂度为 O(n) 的算法解决本问题

自己的思路

F1：冒泡排序

最开始没有想到复杂度为O(n)的算法，直接用冒泡排序做了，完整代码如下：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
vector<int> sortedSquares(vector<int>& nums) {
int len = nums.size(), temp;
	temp = nums[0];
	for (int i = 0; i < len; i++)
		nums[i] = pow(nums[i], 2);
	//判断是否为特殊情况
	if (temp >= 0)
		return nums;
	//冒泡排序
	for (int j = 0; j < len; j++)
		for (int k = 0; k < len - j - 1; k++) {
			if (nums[k] > nums[k + 1])
			{
				temp = nums[k];
				nums[k] = nums[k + 1];
				nums[k + 1] = temp;
			}
		}
	return nums;
}
int main() {
	vector<int> nums, result;
	int num;
	char chr;
	while (cin >> num) {
		nums.push_back(num);
		cin.get(chr);
		if (chr != ' ')
			break;
	}
	result = sortedSquares(nums);
	system("pause");
	return 0;
}

复杂度

• 时间复杂度：O(n²)
• 空间复杂度：O(1)

F2:暴力排序使用内置的排序方法sort

vector<int> sortedSquares(vector<int>& nums) {
	for (int i = 0; i < nums.size(); i++)
		nums[i] *= nums[i];
	sort(nums.begin(), nums.end());
	return nums;
}

复杂度

• 时间复杂度：O(nlogn)
• 空间复杂度：O(1)

其他好的解法

F3：双指针法

需要考虑的问题是：数组中可能有负数，平方之后可能会很大。
思路：数组的最大值只可能在数组的头或者尾部，所以对比平方的头尾。两个指针分别对应数组头尾，额外开辟一个数组result用于存储排序后的数组，result下标初始为原始数组长度len-1；

• 每次对头尾两个元素平方后的值进行对比，那个大就把存入result数组的尾部，下标更新；
• 指向元素大的指针更新，元素平方值小的一边指针不动；
  

声明：动态图片是从代码随想录里面copy过来的

//F3 双指针算法，思路：头尾指针 + 新建的数组，复杂度为O(n)
vector<int> sortedSquares(vector<int>& nums) {
	int k = nums.size() - 1, l, r;//新数组长度下标
	vector<int> result(nums.size(), 0);//建立新数组，并初始化
	for (l = 0, r = nums.size() - 1; l <= r;) { //如果是小于的话，会少一个数组元素
		if (nums[l]*nums[l] >= nums[r]*nums[r]) { //左侧值大
			result[k--] = nums[l] * nums[l];
			l++;
		}
		else { //右侧值大
			result[k--] = nums[r] * nums[r];
			r--;
		}
	}
	return result;
}

• 时间复杂度：O(n)
• 空间复杂度：O(n)，因为重新定义了一个数组

总结

题目不难，有思路，但是实现方法的思路不够简洁，复杂度较高，双指针法还是牛的。