代码随想录算法训练营打卡day02-3|977 有序数组的平方（相向双指针法）

最新推荐文章于 2024-09-12 19:02:20 发布

夹喵喵的小螃蟹

最新推荐文章于 2024-09-12 19:02:20 发布

阅读量67

点赞数

分类专栏：代码随想录算法训练营打卡文章标签：算法

本文链接：https://blog.csdn.net/yekongtk/article/details/131543056

版权

代码随想录算法训练营打卡专栏收录该内容

13 篇文章 0 订阅

订阅专栏

学习来自《代码随想录》

题目建议：本题关键在于理解双指针思想

题目链接：力扣

文章讲解：代码随想录

视频讲解：双指针法经典题目 | LeetCode：977.有序数组的平方_哔哩哔哩_bilibili

977 有序数组的平方（相向双指针法）

1 题目描述

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

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

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

2 我的思路

1、暴力解法是平方后再排序，也不是说错误，只是失去了本题思想意义，复杂度高

2、双指针，需要额外的一个新数组空间存放结果，因为指针在头尾，此时平方出来的结果是最大值，所以要从最后（最大）往前填充新数组。

~~当前后指针遇到相同的绝对值的数时，往数组里填两个，并同时向中间前进指针。~~

此处考虑复杂了，实现时出现了，当原数组为[-5,-3,2,3,8]的情况时，头尾指针都指向2时，新数组有越界的风险。

实际上不用考虑相同的情况，相同时也只放一个元素，另外一个元素进入下次比较即可。

错误代码：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] numsResult = new int[nums.length];
        int head = 0;
        int last = nums.length - 1;
        int i = nums.length - 1;

        while(head <= last){
            if(Math.abs(nums[head]) < Math.abs(nums[last])){
                numsResult[i] = nums[last]*nums[last];
                last--;
            }else if(Math.abs(nums[head]) > Math.abs(nums[last])){
                numsResult[i] = nums[head]*nums[head];
                head++;
            }else if(Math.abs(nums[head]) == Math.abs(nums[last])){
               numsResult[i] = nums[head]*nums[head];
               numsResult[--i] = nums[last]*nums[last];
               head++;
               last--;
            }//把绝对值相等的情况单独拎出来写，当head=last时，会越界
            i--;
        }
        return numsResult;
    }
}

3 题解

数组其实是有序的，只不过负数平方之后可能成为最大数了。

那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。

此时可以考虑双指针法了，head指向起始位置，last指向终止位置。

java版本：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] numsResult = new int[nums.length];
        int head = 0;
        int last = nums.length - 1;
        int i = nums.length - 1;

        while(head <= last){
            if(Math.abs(nums[head]) < Math.abs(nums[last])){
                numsResult[i] = nums[last]*nums[last];
                last--;
            }else if(Math.abs(nums[head]) >= Math.abs(nums[last])){
                numsResult[i] = nums[head]*nums[head];
                head++;
            }
            i--;
        }
        return numsResult;
    }
}

复杂度分析

时间复杂度O(n)

空间复杂度O(n) 需要一个长度为n的新数组

python 版本：

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        list = [0 for _ in range(len(nums))]
        head = 0
        last = len(nums) - 1
        i = len(nums) - 1
         
        while head <= last:
            if abs(nums[head]) < abs(nums[last]):
                list[i] = nums[last] * nums[last]
                last -= 1
            elif abs(nums[head]) >= abs(nums[last]):
                list[i] = nums[head] * nums[head]
                head += 1
            i -=1

        return list

复杂度分析

时间复杂度O(n)

空间复杂度O(n) 需要一个长度为n的新数组