python实现——LeetCode977 ： 有序数组的平方

题意：

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

示例：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

提示：

• 1 <= nums.length <= 104
• -104 <= nums[i] <= 104
• nums 已按 非递减顺序 排序

进阶：

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

我的解法：冒泡

思路：

先平方再用冒泡法排序

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        squares = []
        for i in range(len(nums)):
            squares.append(nums[i]**2)
        for j in range(len(squares)):
            for k in range(len(squares)-j-1):
                if squares[k] > squares[k+1]:
                    squares[k],squares[k+1] = squares[k+1],squares[k]
        return squares

分析：

执行结果：超出时间限制！时间复杂度为O（n^2）

大神解法

方法一：双指针法

   #### 思路：

数组 nums 是非递减排序的数组，那就相当于是个递增的数组，且每个元素的取值 -10^4 <= nums[i] <= 10^4，这就证明元素值有正有负。

通过这两个条件其实我们可以得出，**平方以后的最大值肯定出现在两侧，不是左边就是右边（负数的平方为正数）**。

碰到这种情况，我们一般祭出**双指针法**来解决，left 指向下标 0，right 指向下标 n - 1：

- 新建一个结果数组 res 存储最后的结果，site 指向数组末尾，数组从后向前存储。
- 若 nums[left] * nums[left] < nums[right] * nums[right]，res[site] = nums[right] * nums[right]。
- 若 nums[left] * nums[left] >= nums[right] * nums[right]，res[site] = nums[left] * nums[left]。

根据提示自己写的代码：

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        left, right,n = 0, len(nums)-1, len(nums)-1
        res = [0]*len(nums)
        while n >= 0:
            if nums[right]**2 >= nums[left]**2:
                res[n] = nums[right]**2
                right -= 1    
            else:
                res[n] = nums[left]**2
                left += 1
            n -= 1
        return res

**大佬代码：**

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:

        if len(nums) == 1:
            return [nums[0] * nums[0]]

        # 初始化双指针
        left = 0
        right = len(nums) - 1

        # 存储结果数组，从数组末尾开始存储
        res = [-1] * len(nums)
        site = len(nums) - 1

        # 注意这里是 <=
        while left <= right:
            # 从两端遍历，将平方数组大得存储在 res 数组中
            if nums[left] * nums[left] < nums[right] * nums[right]:
                res[site] = nums[right] * nums[right]
                right -= 1
            else:
                res[site] = nums[left] * nums[left]
                left += 1

            site -= 1

        return res

#### 复杂度分析

时间复杂度：O(n)，其中 nn 是数组 nums 的长度。

空间复杂度：O(1)。除了存储答案的数组以外，我们只需要维护常量空间。

方法二：直接排序法（我叹为观止……）

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        return sorted(num * num for num in nums)

#### 复杂度分析

时间复杂度：O(nlogn)，其中 n 是数组 nums 的长度。

空间复杂度：O(logn)。除了存储答案的数组以外，我们需要 O(logn) 的栈空间进行排序。