数组-Part02

He_yiiii

已于 2024-01-15 16:05:52 修改

阅读量333

点赞数 8

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

于 2024-01-14 23:31:25 首次发布

本文链接：https://blog.csdn.net/He_yiiii/article/details/135586599

版权

有序数组的平方-双指针排序

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

原来的数组的已经是排序数组了，因此如果数组没有负数项时，是不需要排序的。

当数组含有负数，如A=[-4,-1,0,3,10]，平方后[16,1,0,9,100] 是以0为中心向两边增大的，因此本题可以采用❗双指针法❗从数组两边开始进行比较，用一个新数组进行接收。

注意：

什么时候移动左右指针？如当nums[i]*nums[i] <= nums[j]*nums[j]时，j 位置排序成功而 i 位置还未排序，因此只需要更新 j
什么时候结束循环？i <= j，❗是<=，不然会出现 i、j指向同一位置而该位置还未排序的情况

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        i = 0
        j = len(nums)-1
        result = [0]*len(nums)
        k = len(nums)-1
    
        while i <= j :
            if nums[i]*nums[i] <= nums[j]*nums[j]:
                result[k] = nums[j]*nums[j]
                j -= 1
            else:
                result[k] = nums[i]*nums[i]
                i += 1
            k -= 1
        return result

长度最小的子数组-滑动窗口

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

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

暴力解法

双循环，比较每次循环的结果取最小

❗①sum跟 l 用于判断符合条件以及计算本次数组串的长度，每次循环都需要更新，必须放在循环里面 ②创建一个初始值为正无穷大的变量min_len = float('inf')

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        min_l = float('inf')
        
        for i in range(0,len(nums)):
            sum = 0
            l = 0
            for j in range(i,len(nums)):
                sum += nums[j]
                l += 1
                if sum >= target:
                    min_l = min(min_l,l)
                    break
            
        return min_l if min_l != float('inf') else 0

滑动窗口

其实就是双指针，通过双指针降低算法的时间复杂度，将暴力解法的双循环变为单循环。

窗口就是满足其和 ≥ s 的长度最小的连续子数组。
窗口的起始位置如何移动：找到了匹配的>=s的数组后，起始位置往后移一位，开始下一种情况的匹配
窗口的结束位置如何移动：结束位置的指针是不断往下移动的，因为在上一个窗口的基础上，起始位置向后移一位后，剩余数组串一定小于S，结束位置只需继续后移，不用重新开始循环

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        min_l = float('inf')
        l = 0
        r = 0
        sum = 0
        while r < len(nums):
            sum += nums[r]
            while sum >= target:
                min_l = min(min_l, r - l + 1)
                sum -= nums[l]
                l += 1  #l的改变要放在最后，不然会影响前面的计算

            r += 1

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

螺旋矩阵II

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

以一圈作为一次循环 (offset = 1,每完成一圈+1）→圈数为n//2
以四个拐角作为处理原则，即以拐角为起点画新的一条边
同一圈的边长相同（第一圈n-1,第二圈n-2）→边长 n-offset
n为奇数时，有中心点需要填充；n为偶数时，完成循环即可
A[i][j] 从左到右：i 不变=x, j 变=从y到n-offset-1 ❗range左闭右开（y,n-offset）
从上到下：j 不变=n-offset，i 变=从x到n-offset-1 剩下以此类推
nums = [[0] * n for _ in range(n)] 创建一个n*n的二维数组

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        nums = [[0] * n for _ in range(n)]
        x,y = 0,0
        loop,mid= n//2,n//2
        count = 1  #不随循环更新，放外面
        for offset in range(1,loop+1):
            #边长 = n-offset  
            for i in range(y,n-offset):  #从左到右
                nums[x][i] = count
                count += 1
            for i in range(x,n-offset):  #从上到下
                nums[i][n-offset] = count
                count += 1
            for i in range(n-offset,y,-1):  #从右到左
                nums[n-offset][i] = count
                count += 1
            for i in range(n-offset,x,-1):  #从下到上
                nums[i][y] = count
                count += 1
            x += 1
            y += 1
        
        if n%2 != 0:
            nums[mid][mid] = count

        return nums