算法学习|Day2-数组|Leetcode977有序数组的平方，Leetcode209长度最小的子数组，Leetcode59螺旋矩阵II-CSDN博客

本文链接：https://blog.csdn.net/WR_mmc/article/details/130005884

一、Leetcode977(有序数组的平方)

题目描述

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

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

题目链接：力扣题目链接

解题思路

暴力算法，直接把数组元素平方再按照升序排序
双指针法，利用数组平方后中间小，两边大的特征，通过比较两边大的元素，依次将大的从右往左放入新的数组中

方法一:暴力算法

先平方，后排序
[-4,-1,0,3,10] -->[16,1,0,9,100] -->[0,1,9,16,100]

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        # 暴力算法
        size = len(nums)
        newnums = [1] * size
        for i in range(size):
            newnums[i] = nums[i]**2
        newnums = sorted(newnums)
        return  newnums

方法二:双指针

定义初始指针位置：i在最左边为0，j在最右边为size-1，k为size-1(从右边开始给新数组赋值)
如果A[i] * A[i] < A[j] * A[j] 那么result[k- -] = A[j] * A[j]
如果A[i] * A[i] >= A[j] * A[j] 那么result[k- -] = A[i] * A[i]，如图

上图流程：当9>1时，k的位置赋值9，j的位置往左移动一个，k的位置往左移动一个，以此类推。

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        # 双指针方法
        size = len(nums)
        i, j, k = 0, size-1, size-1
        newnums = [1] * size   # 新建一个一样大小的数组，初始值都为1
        while i <= j:
            if nums[i]**2 < nums[j]**2:
                newnums[k] = nums[j]**2
                j -= 1
            else:
                newnums[k] = nums[i]**2
                i += 1
            k -= 1
        return newnums

总结

要new一个数组，不然k走的更快会覆盖j位置的值，初始化数组：newnums = [1] * size
sorted()即为升序排序
双指针法的循环条件是i<=j(不要漏了=，i和j最后会走到同一位置)

二、Leetcode209(长度最小的子数组)

题目描述

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

输入：target = 4, nums = [1,4,4]
输出：1

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

题目链接：力扣题目链接

解题思路

暴力算法，需要两个循环，起始位置和终止位置。
滑动窗口，减少时间复杂度，只循环终止位置。

方法一:暴力算法

第一个循环确定起始位置
第二个循环遍历终止位置，直到和 ≥ target，记录最小子数组元素个数

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        # 暴力算法
        i = 0
        sublength = 0
        result = float("inf") #设置成最大值，更小则覆盖值
        for i in range(len(nums)):
            sum = 0
            for j in range(i, len(nums)):
                sum += nums[j]
                if sum >= target:
                    sublength = j - i + 1
                    if sublength < result:
                        result = sublength
                    break
                j += 1
            i += 1
        # 输出
        if result != float("inf"):
            return result
        else:
            return 0

方法二:滑动窗口

如何移动窗口起始位置i：当和>=target
如何移动窗口终止位置j：当和<target，如下图

在这里插入图片描述

上图流程：target=7，当和为1+2+4=7时，i向左移动一个，此时和为2+4=6<target，j向右移动一个，依次类推。

class Solution(object):
    def minSubArrayLen(self, target, nums):
        """
        :type target: int
        :type nums: List[int]
        :rtype: int
        """
        # 滑动窗口
        i = 0
        sum = 0
        result = float("inf")
        for j in range(len(nums)):
            sum += nums[j]
            # 窗口起始位置如何移动！！
            while sum >= target:
                result = min(result, j - i + 1)
                sum -= nums[i]
                i += 1
        return 0 if result == float("inf") else result

总结

result = float(“inf”) #找最小值，先设置成最大值
注意窗口起始位置怎么移动！！
while控制，当和>=target，起始位置一直向右移动，直到找到子数组最少元素个数

三、Leetcode59(螺旋矩阵II)

题目描述

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

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

输入：n = 1
输出：[[1]]

题目链接：力扣题目链接

解题思路

Day1的二分法中循环不变量思想[left,right)
想清楚四个边的循环变化和圈数

方法:模拟过程

四个边都按照[left,right)的区间划分
圈数为n//2(画出n*n矩阵类比)
偏移值offset从1开始，每一圈递增1(循环几圈递增几次)
若n为奇数，要单独赋值中心值nums[mid][mid]

class Solution(object):
    def generateMatrix(self, n):
        """
        :type n: int
        :rtype: List[List[int]]
        """
        # 初始化
        nums = [[1] * n for _ in range(n)]  # 初始化n*n二维数组
        startx, starty = 0, 0  # 起始位置
        loop = n // 2  # 循环圈数
        mid = n // 2  # 若n为奇数，存在中心值nums[mid][mid]
        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

        # 循环完所有圈，若n为奇数，给中心值赋值
        if n % 2 != 0:
            nums[mid][mid] = count
        return nums

总结

初始化二维数组：nums = [[1] * n for _ in range(n)]
完成一圈循环要改变初始位置[startx][starty]
n为奇数，要单独给中心值赋值

心得：坚持到Day2了，后面两题是力扣中等题还是蛮难的orz…