代码随想录算法训练营-数组章节

Leetcode 刷题记录 Day1

704. Binary Search

不变量是区间：1. 左闭右闭 2. 左闭右开 对应不同的更新区间方式

左闭右闭 [left, right]: right 初始值为len(nums) - 1, while left <= right循环,

•         if middle > target, 更新右边界，检查[left, middle - 1]区间, right = middle - 1
•         if middle < target, 更新左边界，检查[middle + 1, right]区间, left = middle + 1
•         if middle == target, return middle
•         遍历循环没找到, return - 1

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        # 左闭右闭区间
        left, right = 0, len(nums) - 1
        while left <= right:
            middle = (left + right) // 2
            if nums[middle] > target:
                right = middle - 1
            elif nums[middle] < target:
                left = middle + 1
            else:
                return middle
        return -1

左闭右开 [left, right): right 初始值为len(nums), 因为一开始区间是[0, len(nums)), while left < right循环

•         if middle > target, 更新右边界，检查[left, middle)区间, right = middle
•         if middle < target, 更新左边界，检查[middle + 1, right)区间, left = middle + 1
•         if middle == target, return middle
•         遍历循环没找到, return - 1

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        # 左闭右开区间
        left, right = 0, len(nums)
        while left < right:
            middle = (left + right) // 2
            if nums[middle] > target:
                right = middle
            elif nums[middle] < target:
                left = middle + 1
            else:
                return middle
        return -1

27. Remove Elements

        注意：list是连续的，要移动后续元素(i.e. 只能覆盖元素，不能删除)

        双指针法：快慢指针，快指针遍历所有元素，当fast != target时，slow指针更新fast的值。所以实际并非删除元素，而是覆盖原数组。

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        fast, slow = 0, 0
        while fast < len(nums):
            if nums[fast] != val:
                nums[slow] = nums[fast]
                slow += 1
            fast += 1
        return slow

34. Find First and Last Position of Element in Sorted Array

        

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        # 用左闭右开区间
        def find_left(nums, target):
            l, r = 0, len(nums)
            while l < r:
                mid = (l + r) // 2
                if nums[mid] < target:
                    l = mid + 1
                if nums[mid] >= target:
                    r = mid
            # target如果在范围内，l永远在第一个target结束
            if len(nums) <= l or nums[l] != target:
                return -1
            return l

        def find_right(nums, target):
            l, r = 0, len(nums)
            while l < r:
                mid = (l + r) // 2
                if nums[mid] <= target:
                    l = mid + 1
                if nums[mid] > target:
                    r = mid
            if len(nums) < l or l == 0 or nums[l - 1] != target:
                return -1
            return l - 1

        return [find_left(nums, target), find_right(nums, target)]

                                

Leetcode 刷题记录 Day2

977.Squares of a Sortd Array

双指针解法: 特点是平方后最大的数一定在两边 ex. [-5, 0, 1, 2, 3]

最大的要么是最左侧的平方数要么是最右侧平方数, 对比nums[left] ** 2和nums[right] ** 2, 得到nums[left:right]中平方后最大的数。

所以定义一个新的数组，从后向前更新(我们的平方数由大到小)

注意: 循环中用的是left <= right, 否则会遗漏left == right的Index

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

209. Minimum Size Subarray Sum

双指针思路(使用滑动窗口): 两个指针指向窗口位置，初始值左右指针都为0，右指针遍历所有位置并记录sum。当sum >= target, 更新“最小长度”, 调整左指针(动态移动)，确保在这个右指针位置下满足条件的的最小长度。

重点掌握如何移动滑动窗口。

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        left, right = 0, 0
        s = 0
        min_len = len(nums) + 1
        while right < len(nums):
            s += nums[right]
            while s >= target:
                min_len = min(min_len, right - left + 1)
                s -= nums[left]
                left += 1
            right += 1
        if min_len == len(nums) + 1:
            return 0
        else:
            return min_len

59. Spiral Matrix II

模拟转圈，注意四条边上边界点(i.e. 四个角)

循环不变量: 在处理每条边时都包含第一个节点不包含最后一个节点, 这样每条边的处理逻辑相同(类似左闭右开)。

对于奇数n，单独处理中间内部节点。

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        res = [[0]*n for _ in range(n)]
        count = 1
        for i in range(n // 2 ):
            # 左到右
            for j in range(i, n - i - 1):
                res[i][j] = count
                count += 1
            # 上到下
            for j in range(i, n - i - 1):
                res[j][n - i - 1] = count
                count += 1
            # 右到左
            for j in range(n - i - 1, i, -1):
                res[n - i - 1][j] = count
                count += 1
            # 下到上
            for j in range(n - i - 1, i, -1):
                res[j][i] = count
                count += 1
        if n % 2 != 0:
            res[n//2][n//2] = count
        return res