代码随想录算法训练营第二天 | 数组理论基础 | 977.有序数组的平方 | 209.长度最小的子数组 | 59.螺旋矩阵II

977.有序数组的平方

977.有序数组的平方-题目链接

TLE（超时算法）

这是我做题的时候最开始想到的，就是先每一个数平方，然后放在一个list里面，然后第二个数插入，这样想其实没错，但是没有充分考虑到一个思路，因为题目给的数组有一个性质，他是排好序的，最大的和最小的数出现在头和尾，所以我遍历的时候应该要头尾遍历

• 先附上最开始出错的代码

nums = [1]
# [0,1,9,16,100]
class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        res=[]
        for i in nums:
            temp=i*i
            # 判断条件 然后插入排序
            if(len(res)==0):
                res.append(temp)
            else:
                for j in range(len(res)):
                    if(temp<res[j]):
                        res.insert(j,temp)
                        break;
                    j+=1
                if (temp >= res[len(res) - 1]):
                    res.append(temp)

        print(res)

if __name__=="__main__":
    solu=Solution()
    solu.sortedSquares(nums)

• 试着改为双指针，有一次TLE

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        res=[]
        i=0
        j=len(nums)-1
        while(i<=j):
            temp=nums[i]*nums[i]
            # 初始化
            if(len(res)==0):
                res.append(temp)
            # 左边
            else:
                for k in range(len(res)):
                    # 是最大值添加
                    if(temp>=res[len(res)-1]):
                        res.append(temp)
                        break
                    # 不是边界插入
                    if(temp>res[len(res)-k-1] and temp<res[len(res)-1]):
                        res.insert(len(res)-k, temp)
                        break
                    # 如果是最小值
                    if(temp<=res[0]):
                        res.insert(0,temp)
                        break
                    k += 1
            i+=1
            if(i<j):
                temp=nums[j]*nums[j]
                for k in range(len(res)):
                    # 是最大值添加
                    if (temp >= res[len(res) - 1]):
                        res.append(temp)
                        break
                    # 不是边界插入
                    if (temp > res[len(res) - k - 1] and temp < res[len(res) - 1]):
                        res.insert(len(res) - k , temp)
                        break
                    # 如果是最小值
                    if (temp <= res[0]):
                        res.insert(0, temp)
                        break
                    k += 1
                j-=1
        return res

成功

好吧好吧，我第二种和第一种其实是一样的，呜呜呜呜呜，需要修改的是i和j的更新不是直接±，也就是我不需要判断循环大小这个操作，而仅仅是让他们自己比较大小，从最后开始往前面插入，那我直接取中间哪个数从最小往最大插入内，这样出现一种情况： [-5,-3,-2,-1]，直接错误输出：[4, 1, 9, 25]。所以还是老实的两边往中间吧，最后熬了我几个小时的代码只有几行，这大概就是算法的魅力吧

nums = [-4,-1,0,3,10]
# [0,1,9,16,100]
class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        res=[0 for i in range(len(nums))]
        i=0
        j=len(nums)-1
        k=len(res)-1
        while(i<=j):
            while(nums[i]**2 > nums[j]**2 and i<=j):
                res[k]=nums[i]**2
                k-=1
                i+=1
            while (nums[i] ** 2 <= nums[j] ** 2 and i <= j):
                res[k] = nums[j] ** 2
                k -= 1
                j-=1
        print(res)

if __name__=="__main__":
    solu=Solution()
    solu.sortedSquares(nums)

977.有序数组的平方-在此处附上视频讲解

209.长度最小的子数组

209.长度最小的子数组-题目链接

思路

啊啊啊啊啊啊看到这道题我还是真的一点思路都没有，于是我就直接去看了视频，然后我发现暴力解法原来是这样解的。两层for循环遍历列表，然后找出每一个区间长度，然后找到。但是我又看了更好的解法，所以我不想做那种hhhhh，所以我就直接说一下更好的吧。
思路是这样的，根据两层for循环得到双指针，然后确定j是指向谁的，有两个位置，首先是起始位置，其次是终止位置，起始位置的话其实就是两层for循环，终止位置的话那就是这题的解法了哈哈哈哈哈

target = 15
nums = [1,2,3,4,5]


# 2
class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        i=0
        j=0
        sum=0
        res=len(nums)+1
        while(j<len(nums) and i<=j):
            sum+=nums[j]
            while(sum>=target):
                subL=j-i+1
                res=min(res,subL)
                sum-=nums[i]
                i+=1
            j+=1
        if(res>len(nums)):
            res=0
        print(res)

if __name__=="__main__":
    solu=Solution()
    solu.minSubArrayLen(target,nums)

209.长度最小的子数组-在此处附上视频讲解

59.螺旋矩阵II

螺旋矩阵II-题目链接

解题思路

不好意思，我还是没有思路
于是乎，我又去看了看代码随想录，我发现是个循环list解决的，填充list即可

class Solution(object):
    def generateMatrix(self, n):
        """
        :type n: int
        :rtype: List[List[int]]
        """
        start=0
        k=1
        offset=1
        res=[[0 for _ in range(n)] for _ in range(n)]
        count=0
        while(count<n//2):
            # 上边
            j=count
            while(j<n-offset and k<=n**2):
                res[start][j]=k
                j+=1
                k+=1
            # 右边
            i=count
            while(i<n-offset and k<=n**2):
                res[i][j]=k
                i+=1
                k+=1
            # 下边
            while(j>start and k<=n**2):
                res[i][j]=k
                j-=1
                k+=1
            # 左边
            while(i>start and k<=n**2):
                res[i][start]=k
                i-=1
                k+=1
            # 更新offset
            offset+=1
            # 更新start
            start+=1
            # 更新圈数
            count+=1

        if(n%2!=0 or count==0):
            res[start][start]=k
        print(res)


if __name__=="__main__":
    solu=Solution()
    solu.generateMatrix(2)

螺旋矩阵II-在此处附上视频讲解