代码随想录 day2:第一章 数组part02

977.有序数组的平方

题目：给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。
输入：nums = [-4,-1,0,3,10]；输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

思路：由于数组平方之后，两边较大，中间较小，设置左右指针，边比较谁大，边放入result中（中间肯定比两边小）。总是把更大的数放入result中，最后result是从大到小排列，将其倒序即可。

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        #左闭右闭
        left,right=0,len(nums)-1
        result=[]
        while left<=right:
            if nums[left]**2<nums[right]**2:#right平方放进去
                result.append(nums[right]**2)
                right-=1
            else:
                result.append(nums[left]**2)
                left+=1
        return result[::-1]

209.长度最小的子数组

题目：给定一个含有 n 个正整数的数组和一个正整数 target 。找出该数组中满足其总和大于等于 target 的长度最小的 子数组[numsl, numsl+1, …, numsr-1, numsr]，并返回其长度。如果不存在符合条件的子数组，返回 0 。

思路： 滑动窗口，双指针；前缀和

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        left,sum=0,0
        ans=len(nums)+1 #ans初始化一个比较大的数，子数组大小不会超过数组本身
        for right,x in enumerate(nums):#right是索引，x是具体值
            sum+=x
            while sum>=target:
                ans=min(ans,right-left+1)
                sum-=nums[left]
                left+=1
        return ans if ans<=len(nums) else 0 #最后一定要判断ans是否小于n

双指针的应用场景：单调性，前缀和。

时间复杂度：O(n)，其中 n 为nums 的长度。
空间复杂度：O(1)，仅用到若干额外变量。

59.螺旋矩阵II

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

思路： 循环不变量，一圈一圈循环；不变量是对每条边的处理规则。

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

713.乘积小于k的子数组

题目：给你一个整数数组 nums 和一个整数 k ，请你返回子数组内所有元素的乘积严格小于 k 的连续子数组的数目。
示例 1：
输入：nums = [10,5,2,6], k = 100
输出：8
解释：8 个乘积小于 100 的子数组分别为：[10]、[5]、[2],、[6]、[10,5]、[5,2]、[2,6]、[5,2,6]。
需要注意的是 [10,5,2] 并不是乘积小于 100 的子数组。

class Solution:
    def numSubarrayProductLessThanK(self, nums: List[int], k: int) -> int:
        left,prod=0,1
        ans=0
        if k<=1:
            return 0
        for right,x in enumerate(nums):
            prod*=x
            while prod>=k:
                prod/=nums[left]
                left+=1
            ans+=right-left+1 #在循环外面
        return ans

3.无重复字符的最长字串

给定一个字符串 s ，请你找出其中不含有重复字符的最长子串的长度。
示例 1:
输入: s = “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        left,ans=0,0#ans初始化为0
        count=Counter() # hashmap, key:char,value:int；主要用来对可哈希对象进行计数
        for right,x in enumerate(s):#不断枚举右端点
            count[x]+=1
            while count[x]>1:
                count[s[left]]-=1 #去除最左边元素，相对应的字符串减1
                left+=1
            ans=max(ans,right-left+1)
        return ans

总结

• 数组是非常基础的数据结构，在面试中，考察数组的题目一般在思维上都不难，主要是考察对代码的掌控能力。
• 要知道数组在内存中的存储方式：数组是存储在连续内存空间上具有相同类型元素的集合。
• 数组可以方便的通过下标索引的方式获取到下标对应的数据。
• 数组下标都是从0开始的。
• 数组内存空间的地址是连续的。
• 正是因为数组在内存空间上的地址是连续的，所以在删除或者增添元素的时候，就需要移动其他元素的地址。
• 数组元素不能删，只能覆盖。