代码随想录算法训练营第2天| 977.有序数组的平方、209.长度最小的子数组、59.螺旋矩阵II-优快云博客

本文链接：https://blog.youkuaiyun.com/dieforcpp/article/details/128843318

977.有序数组的平方

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

题目链接：Squares of a Sorted Array - LeetCode

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

Given an integer array nums sorted in non-decreasing order, return an array of the squares of each number sorted in non-decreasing order.

Example 1:
Input: nums = [-4,-1,0,3,10]
Output: [0,1,9,16,100]
Explanation: After squaring, the array becomes [16,1,0,9,100].
After sorting, it becomes [0,1,9,16,100].
Example 2:
Input: nums = [-7,-3,2,3,11]
Output: [4,9,9,49,121]

解题思路：

暴力解题（超时）

1. 全部平方

2. bubble sort

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        nums=[i**2 for i in nums]
        for i in range(len(nums)-1,0,-1):
            for j in range(i):
                if nums[j]>nums[j+1]:
                    nums[j],nums[j+1]=nums[j+1],nums[j]
        return nums

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

左右指针

1. 创建一个size相同的list

2. 进入循环，当左<=右时，比较左右两侧数字，较大的录入list最后一个数字，后更新cur value（cur-=1）

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        left=0
        right=len(nums)-1
        cur=len(nums)-1
        result=[0]*len(nums)
        while left<=right:
            left_value = nums[left]**2
            right_value = nums[right]**2
            if left_value < right_value:
                result[cur]=right_value
                right-=1
            else:
                result[cur]=left_value
                left+=1
            cur-=1
        return result

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

209.长度最小的子数组

题目建议：本题关键在于理解滑动窗口，这个滑动窗口看文字讲解还挺难理解的，建议大家先看视频讲解。拓展题目可以先不做。

题目链接：Minimum Size Subarray Sum - LeetCode

文章讲解：代码随想录

视频讲解：拿下滑动窗口！ | LeetCode 209 长度最小的子数组_哔哩哔哩_bilibili

解题思路：

暴力解法（没写）两个for loop列出所有sum的可能情况，取最小的。

时间复杂度：O(n^2)
空间复杂度：O(1)

sliding window（也是一种双指针）

1. 设置一个左指针0

2. 进入for循环，条件设为sliding window的终点指针（右），当右指针扩大时，更新sum，如果sum大于要求的value，更新结果（最小sublist的长度），同时缩小window，也就是移动左指针直到sum小于要求的value。

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        sum = 0
        result=float('inf')
        cur=0
        for i in range(len(nums)):
            sum+=nums[i]
            while sum >= target:
                result = min(result,i-cur+1)
                sum-=nums[cur]
                cur += 1
        return 0 if result==float('inf') else result

时间复杂度：O(n)
主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。
空间复杂度：O(1)

59.螺旋矩阵II

题目建议：本题关键还是在转圈的逻辑，在二分搜索中提到的区间定义，在这里又用上了。

题目链接：Spiral Matrix II - LeetCode

文章讲解：代码随想录

视频讲解：一入循环深似海 | LeetCode：59.螺旋矩阵II_哔哩哔哩_bilibili

Given a positive integer n, generate an n x n matrix filled with elements from 1 to n2 in spiral order.

Example 1:
Input: n = 3
Output: [[1,2,3],[8,9,4],[7,6,5]]
Example 2:
Input: n = 1
Output: [[1]]

解题思路：

固定循环作闭右开

设置我们需要loop的次数，n//2

层层遍历（loop数）

1. 左上到右上（橙色）

2. 右上到右下（蓝色）

3. 右下到左下（绿色）

4. 左下到右上（紫色）

在这里插入图片描述

注意区别odd和even的区别，当odd时我们的loop不会包含最中间的数，所以我们要注意当我们的n为odd时加上它。

class Solution(object):
    def generateMatrix(self, n):
        """
        :type n: int
        :rtype: List[List[int]]
        """
        result=[[0]*n for _ in range(n)]
        loop=n//2
        mid=n//2
        start_i,start_j=0,0
        count=1
        for offset in range(1,1+loop):
            for j in range(start_i,n-offset):
                result[start_i][j]=count
                count+=1
            for i in range(start_i,n-offset):
                result[i][n-offset]=count
                count+=1
            for j in range(n-offset,start_i,-1):
                result[n-offset][j]=count
                count+=1
            for i in range(n-offset,start_j,-1):
                result[i][start_j]=count
                count+=1
            start_i+=1
            start_j+=1
        if n%2 == 1:
            result[mid][mid]=count
        return result