leetcode-数组【三刷3,6,7need again】

1、二分法

我们定义 target 是在一个在左闭右闭的区间里，也就是[left, right] 所以有如下两点：

• while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=；
• if (nums[middle] > target) right 要赋值为 middle -
  1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1。

定义 target 是在一个在左闭右开的区间里，也就是[left, right) ，有如下两点：

• while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的；
• if (nums[middle] > target) right 更新为
  middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]。

2、有序数组的平方(done)

977 有序数组的平方
使用两个指针分别指向位置 0和 n-1，每次比较两个指针对应的数，选择较大的那个逆序放入答案并移动指针。

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        l,f = 0,len(nums)-1

        res = []
        while l <= f:
            if nums[f]**2 > nums[l]**2:
                res.append(nums[f] **2)
                f -= 1
            else:
                res.append(nums[l] **2)
                l += 1
        return res[::-1]

3、长度最小的子数组(done)

209 长度最小的子数组
滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

• 窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。
• 窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。
• 窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，窗口的起始位置设置为数组的起始位置就可以了。

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        n = len(nums)

        left = 0
        total = 0
        minSub = float("inf") 
        for j in range(n):
            total += nums[j]
            while total >= target:
                minSub = min(minSub,j-left+1)
                total -= nums[left]
                left += 1
            
        return minSub if minSub != float("inf") else 0 

4、螺旋矩阵 II（done）

59. 螺旋矩阵 II

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        m = [[0]*n for _ in range(n)]
        top,left,right,buttom = 0,0,n-1,n-1

        num = 1
        while top <= buttom and left <= right:
            #左->右 
            for i in range(left,right+1):
                m[top][i] = num
                num += 1
            top += 1 

            #上->下 
            for i in range(top,buttom+1):
                m[i][right] = num
                num += 1
            right -= 1 

            #右->左 
            for i in range(right,left-1,-1):
                m[buttom][i] = num
                num += 1
            buttom -= 1 

            #下->上 
            for i in range(buttom,top-1,-1):
                m[i][left] = num
                num += 1
            left += 1 
        return m

5、移除元素(done)

27. 移除元素I

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        res = list()
        for i in nums:
            if i != val:
                res.append(i)
        nums[:] = res
        return len(nums)

6、 二维数组中的查找（done）

04. 二维数组中的查找

class Solution:
    def Find(self , target: int, array: List[List[int]]) -> bool:
        # write code here
        n = len(array)
        m = len(array[0])
        
        if n == 0 or m == 0:
            return False
        
        left,right = n-1,0
        while left >= 0 and right < m:
            total = array[left][right]
            if total == target:
                return True
            elif total > target:
                left -= 1
            else:
                right += 1
        return False

7、旋转数组的最小数字（二分法）

剑指 Offer 11. 旋转数组的最小数字

class Solution:
    def minArray(self, numbers: List[int]) -> int:
        low, high = 0, len(numbers) - 1
        while low < high:
            pivot = low + (high - low) // 2
            if numbers[pivot] < numbers[high]: #右边有序且递增，故最小值在左边
                high = pivot 
            elif numbers[pivot] > numbers[high]:
                low = pivot + 1
            else: #nums[m]=nums[j] 时： 无法判断 m 在哪个排序数组中，即无法判断旋转点 x 在 [i,m] 还是[m+1,j] 区间中。解决方案： 执行j=j−1 缩小判断范围
                high -= 1
        return numbers[low]

8、数组中的逆序对（hard)

剑指 Offer 51. 数组中的逆序对

9、数据流中的中位数（hard)

剑指 Offer 41. 数据流中的中位数