Leetcode刷题第二天 | Leetcode 977，209，59

最新推荐文章于 2024-07-14 11:23:58 发布

一只AI学习小朋友

最新推荐文章于 2024-07-14 11:23:58 发布

阅读量54

点赞数

分类专栏： Leetcode刷题文章标签： leetcode 算法 python

本文链接：https://blog.csdn.net/m0_46690443/article/details/132482101

版权

Leetcode刷题专栏收录该内容

23 篇文章 0 订阅

订阅专栏

Leetcode 977 有序数组的平法，Leetcode 27 长度最小的子数组，Leetcode 螺旋矩阵II

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^4$
- $10^4$ <= nums[i] <= $10^4$
nums已按非递减顺序排序

实现方法： 利用双指针解决问题，头指针指向开始位置，尾指针指向结尾位置；两个指针分别从左向右运动和从从右向左运动，直到两个指针相遇，即为结束条件。
代码实现

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        l, r, i = 0, len(nums)-1, len(nums)-1	# l 左指针；r 右指针；i 存放结果的指针
        res = [float('inf')] * len(nums) # 需要提前定义列表，存放结果
        while l <= r:
            if nums[l] ** 2 < nums[r] ** 2: # 左右边界进行对比，找出最大值
                res[i] = nums[r] ** 2
                r -= 1 # 右指针往左移动
            else:
                res[i] = nums[l] ** 2
                l += 1 # 左指针往右移动
            i -= 1 # 存放结果的指针需要往前平移一位
        return res

**注意：**为什么while $l <= r$ 而不是while $l < r$ ?
如果 $l < r$ ，那就意味着 $l$ 和 $r$ 相等的位置即循环结束的位置，最终不会加入到结果列表中。
复杂度：
时间复杂度： $O (n)$

Leetcode 209

给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其和 ≥ target 的长度最小的连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
示例 1：
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
示例 2：
输入：target = 4, nums = [1,4,4]
输出：1
示例 3：
输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0
提示：

1 <= target <= $10^9$
1 <= nums.length <= $10^5$
1 <= nums[i] <= $10^5$

实现方法： 暴力实现和滑动窗口法
代码实现：

class Solution:
    def minSubArrayLen(self, s: int, nums: List[int]) -> int:
        l = len(nums)
        left = 0
        right = 0
        min_len = float('inf')
        cur_sum = 0 #当前的累加值
        
        while right < l:
            cur_sum += nums[right]
            
            while cur_sum >= s: # 当前累加值大于目标值
                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

复杂度：

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

注意：
为什么时间复杂度是 $O (n)$ ？在外层循环中，所有数组元素被遍历一次，而在内层循环中，每个元素也是被遍历一次，因此时间复杂度没有达到 $O(n^2)$
例如：与冒泡排序不同，冒泡排序最多需要 $n - 1$ 次操作可以将所有元素排序，每一次操作都需要比较两个元素的大小，也就是总的比较和交换次数达到 $O(n^2)$ 的级别。

Leetcode 59

给你一个正整数 n ，生成一个包含 1 到 $n^2$ 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
示例 1：
输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]
示例 2：
输入：n = 1
输出：[[1]]
提示：
1 <= n <= 20

实现方式：
逐个边遍历，填充数据。

代码实现

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        nums = [[0] * n for _ in range(n)]
        startx, starty = 0, 0               # 起始点
        loop, mid = n // 2, n // 2          # 迭代次数、n为奇数时，矩阵的中心点
        count = 1                           # 计数

        for offset in range(1, loop + 1) :      # 每循环一层偏移量加1，偏移量从1开始
            for i in range(starty, n - offset) :    # 从左至右，左闭右开
                nums[startx][i] = count
                count += 1
            for i in range(startx, n - offset) :    # 从上至下
                nums[i][n - offset] = count
                count += 1
            for i in range(n - offset, starty, -1) : # 从右至左
                nums[n - offset][i] = count
                count += 1
            for i in range(n - offset, startx, -1) : # 从下至上
                nums[i][starty] = count
                count += 1                
            startx += 1         # 更新起始点
            starty += 1

        if n % 2 != 0 :			# n为奇数时，填充中心点
            nums[mid][mid] = count 
        return nums