代码随想录算法训练营第二天|LeetCode977 有序数组的平方、LeetCode209 长度最小的子数组、LeetCode59 螺旋矩阵II、数组总结

Avory

已于 2023-12-03 22:39:10 修改

阅读量39

点赞数

文章标签：算法矩阵 leetcode 数据结构 python

于 2023-12-01 20:51:01 首次发布

本文链接：https://blog.csdn.net/Avory/article/details/134743608

版权

代码随想录算法训练营第二天|LeetCode977 有序数组的平方、LeetCode209 长度最小的子数组、LeetCode59 螺旋矩阵II、数组总结

Leetcode977 有序数组的平方

题目链接：https://leetcode.cn/problems/squares-of-a-sorted-array/description/

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

代码描述

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
    ''' 双指针法
    	时间复杂度：O(n)
    	空间复杂度：O(1)
    	'''
        left, right = 0, len(nums)-1
        i = len(nums) - 1
        nums_2 = [float('inf')] * len(nums) 
        while left <= right:
            if (nums[left])**2 > (nums[right])**2:
                nums_2[i] = (nums[left])**2
                left += 1
            else:
                nums_2[i] = (nums[right])**2
                right -= 1
            i -= 1
        return nums_2

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
    ''' 暴力法
    	时间复杂度：O(n^2)	冒泡排序
    	空间复杂度：O(1)
    	'''
        length = len(nums)
        for i in range(length):
            nums[i] = nums[i] ** 2
        for i in range(length):
            for j in range(i+1, length):
                if nums[i] > nums[j]:
                    a = nums[j]
                    nums[j] = nums[i]
                    nums[i] = a
        return nums

暴力排序时可以直接采用sort方法，时间复杂度是O(nlogn)，空间复杂度是O(1)

original_list.sort()

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
		''' 暴力法
		时间复杂度：O(nlogn)		使用sort()方法
		空间复杂度：O(1)
		'''
        for i in range(len(nums)):
            nums[i] *= nums[i]
        nums.sort()
        return nums

列表的 sort() 方法用于原地排序。
sort() 方法对字符串使用字母顺序排序，对数字从小到大进行排序。
sort(reverse=True) 用于反向排序。
sorted 函数返回一个新的已排序列表，而不修改原始列表。

sorted_list = sorted(original_list)

sorted 函数时间复杂度是O(nlogn)，空间复杂度是O(n)

LeetCode209 长度最小的子数组

题目链接：https://leetcode.cn/problems/minimum-size-subarray-sum/

给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其总和大于等于 target 的长度最小的连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

代码描述

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
    ''' 滑动窗口法
    	时间复杂度：O(n)  [2xn也是O(n)]
    	空间复杂度：O(1)
    	'''
        l = len(nums)
        left, right = 0, 0
        min_len = float('inf')		#表示正无穷
        cur_sum = 0        #当前的累加值

        while right < l:
            cur_sum += nums[right]

            while cur_sum >= target:
                min_len = min(min_len, right - left + 1)        # 先存储了之前符合要求的长度，再减少长度
                cur_sum -= nums[left]
                left += 1
            
            right += 1
        
        return min_len if min_len != float('inf') else 0

说明
float(“INF”)表示为正无穷；float(“-INF”)表示负无穷；

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
    ''' 暴力法
    	时间复杂度：O(n^2)
    	空间复杂度：O(1)
    	'''
        l = len(nums)
        min_len = float('INF')

        for i in range(l):
            cur_sum = 0
            for j in range(i, l):
                cur_sum += nums[j]
                if cur_sum >= target:
                    min_len = min(min_len, j - i + 1)
                    break

        return min_len if min_len != float('inf') else 0

Leetcode59 螺旋矩阵Ⅱ

题目链接：https://leetcode.cn/problems/spiral-matrix-ii/description/

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

代码描述

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
    ''' 时间复杂度：O(n^2)
    	空间复杂度：O(n^2)
        nums = [[0 for _ in range(n)] for _ in range(n)]    # 创建一个 n * n 的矩阵
        # nums = [[0] * n for _ in range(n)]                # 两种表达是一样的
        loop, mid = n // 2, n // 2          # 迭代次数；n为奇数时中心点
        startx, starty = 0, 0               # 起始点
        count = 1                           # 计数

        for offset in range(1, loop + 1):   # 每循环一次偏移量+1，偏移量从1开始
            for j in range(starty, n - offset):             # 从左至右；左闭右开
                nums[startx][j] = count
                count += 1
            for i in range(startx, n - offset):             # 从上至下
                nums[i][n - offset] = count
                count += 1
            for j in range(n - offset, starty, -1):         # 从右至左
                nums[n - offset][j] = count
                count += 1
            for i in range(n - offset, startx, -1):         # 从下至上
                nums[i][startx] = count
                count += 1
            
            startx += 1
            starty += 1
        
        if n % 2 != 0:          # 如果是奇数圈，即n是奇数，填充中心点
            nums[mid][mid] = count
        
        return nums