DAY2:977.有序数组的平方&&209长度最小的子数组&&59.螺旋矩阵

最新推荐文章于 2024-10-20 10:43:07 发布

啊噗up

最新推荐文章于 2024-10-20 10:43:07 发布

阅读量197

点赞数

分类专栏：刷题文章标签：算法数据结构

本文链接：https://blog.csdn.net/weixin_45833996/article/details/129291244

版权

刷题专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章介绍了在LeetCode上的三道编程题目，分别是有序数组的平方、找到长度最小的子数组使得其和大于等于目标值、螺旋矩阵的第二形式。分别探讨了使用直接排序、双指针法和滑动窗口法的解题思路，同时提到了Python中sort和sorted的区别，以及在编写代码时的一些注意事项，如循环不变量和代码整洁性。

摘要由CSDN通过智能技术生成

977.有序数组的平方（力扣题目传送门）

方法一：

看完题目，脑袋里直接 ‘ 这不直接平方然后sort！’(~~完了有想法之后还有笨蛋不记得Python的排序函数sort和sorted有啥不一样~~)

简单小记：

1.sort是应用在列表上的方法，属于列表的成员方法，而sorted是Python内置的全局方法，可以对所有可迭代对象进行排序操作

2.list的sort方法是对已存在的列表进行操作；而内建函数sorted的结果会返回一个新生成的列表，而不是在原有列表的基础上进行操作

3.sort的使用方法为list.sort()，而sorted的使用方法为sorted(list)

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        l = len(nums)
        for i in range(l):
            nums[i]=nums[i]*nums[i]
        nums=sorted(nums)
        return nums

之后再卡哥题解里看到对这个算法的时间复杂度：

“这个时间复杂度是 O(n + nlogn)，可以说是O(nlogn)的时间复杂度，但为了和下面双指针法算法时间复杂度有鲜明对比，我记为 O(n + nlog n)。”

不过这个时间复杂度应该是基于C++里sort函数内部实现得到的复杂度，去学习了一下python的sorted()的内部实现（这是一篇讲了timesort的博文！）

方法二：双指针法

~~enmmm过程怪不容易的~~

双指针没把我打败，python的深浅拷贝给我整迷糊了！默默学习一遍~（给个传送门，这篇讲深浅拷贝很清晰）

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        head=0
        tail = len(nums)-1
        k=tail
        # nums_n = copy.deepcopy(nums)
        nums_n = [-1] * (tail +1)
        while head<=tail:
            if nums[head]*nums[head] <nums[tail]*nums[tail]: 
                nums_n[k] =nums[tail]*nums[tail]
                k-=1
                tail-=1
            else: 
                # nums[head]*nums[head] > nums[tail]*nums[tail]:
                nums_n[k] = nums[head]*nums[head]
                head+=1
                k-=1
            # else:#其实你这块的等于不用判断啊 直接并入else里面不就好了
            #     nums_n[k] = nums[tail]*nums[tail]
            #     nums_n[tail-1] = nums[head]*nums[head]
            #     head+=1
            #     tail-=1
        return nums_n

209.长度最下的子数组（力扣题目传送锚点）

刚开始写代码，暴力解法思路好想，但是循环嵌套总是能把自己绕进去

方法一：暴力解法

时间复杂度O(n^2)

写的时候也debug了很多次，边debug边加if来限制（晕应该没错但是在力扣中提交超时了）

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        head = 0
        l = len(nums) - 1
        tail = 0
        count =0 
        temp =0
        while head<=l:
            result = 0
            while (result <target)and(tail<=l):
                result =result + nums[tail]
                count +=1
                tail +=1
            if result<target:
                return temp
            if temp==0:
                temp = count
            if temp>=count:
                temp = count
            count =0
            head+=1
            tail=head
        return temp

方法二：滑动窗口法

这里的代码看完题解写的，虽然理解滑动窗口了

但是对于定义一个无限大的数

对于每一个获取的子数组长度的处理还是要反复思索

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        res = float("inf")  
        Sum = 0     # 滑动窗口数值之和
        i = 0      # 滑动窗口起始位置
        for j in range(len(nums)):
            Sum += nums[j]
            while Sum >= target:
                res = min(res, j-i+1)
                Sum -= nums[i]
                i += 1
        return 0 if res == float("inf") else res

59.螺旋矩阵二（力扣题目传送锚点）

看完题目也没啥思路，就看了题解！要坚持循环不变量原则让我大为震撼~嘻

确保每个行或者列处理时，选择[left,right)就都保持一致，这样才不至于最后debug时，边debug边写if，最后也没用if限定出最终答案，最后还给自己整晕了

还有就是书写代码时的offset用来控制每次循环遍历的时候何时终止，相当于每次的‘偏移量’（大概可以这么理解吧）

（插几句自己写代码的小陋习们：

1.空格合理使用空格使代码看起来不拥挤

2.命名 startx，starty，offset，loop，mid...这种挺常用的，多看几眼，以后别起名废最后自己都不知道是啥

3.对python定义数组的方法不熟悉

4.python的for循环，没有i--,但有把步长设置为-1）

下面是代码：（因为我的最开始写的很乱很乱，自己也进循环了，也没走出来，就复现卡哥代码啦顺便把注释捞来方便以后理解）

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

数组部分完结了，自己写的挺慢的，拓展题目也还没有看，经常犯迷糊，下一趴整理一下python的数组定义，以及做一下数组方面的总结吧