周报1.1

题目：

第一天：剑指 Offer 34. 二叉树中和为某一值的路径

第二天：剑指 Offer 36. 二叉搜索树与双向链表

第三天：11. 盛最多水的容器

第四天：704. 二分查找        27. 移除元素

第五天：209. 长度最小的子数组

第六天：59. 螺旋矩阵 II

第七天：203. 移除链表元素

收获：

1.在要返回多个列表组成的列表时要先pop()列表中的元素：

class Solution:

    def pathSum(self, root: TreeNode, target: int) -> List[List[int]]:

        #创建两个list()，res用来存储最终的答案，path用来存放中途的数据

        res, path = [], []              

        #recur函数用来进行dfs

        def recur(root, target):

            if not root: return

            path.append(root.val)

            target -= root.val

            if target == 0 and not root.left and not root.right:

                #将整个path都append给res

                res.append(list(path))

            recur(root.left, target)

            recur(root.right, target)

            #将已经满足条件的储存在path中的数pop()寻找下一个满足的list

            path.pop()

        

        recur(root, target)

        return res

2.还存在一些问题，逻辑看懂了，在代码上实现有点没看懂

核心：self.pre.right, cur.left = cur, self.pre，把前一个结点的后结点赋值为当前结点，当前结点的前结点设为前一个结点

class Solution:

    def treeToDoublyList(self, root: 'Node') -> 'Node':

        #二叉树中right表示下一个结点, left表示上一个结点

        #cur表示正在访问的结点，pre表示上一个结点

        def dfs(cur):

            if not cur: return

            #dfs左子树

            dfs(cur.left)

            #pre不为空修改双向结点

            if self.pre:

                self.pre.right, cur.left = cur, self.pre

            #访问第一个结点

            else:

                self.head = cur

            self.pre = cur

            dfs(cur.right)

        if not root: return

        self.pre = None

        dfs(root)

        #修改引用

        self.head.left, self.pre.right = self.pre, self.head

        return self.head

3.双指针用法，在边界条件左指针，取值并右移，右指针同理（本题只能max（min（边界）×宽度））

class Solution:

    def maxArea(self, height: List[int]) -> int:

        #双指针

        i, j, res = 0, len(height) - 1, 0

        while i < j:

            #右边更高，左指针右移

            #左边更高，右指针左移

            if height[i] < height[j]:

                res = max(res, height[i] * (j - i))

                i += 1

            else:

                res = max(res, height[j] * (j - i))

                j -= 1

        return res

4.标准二分查找，        快慢指针

疑问点：为什么返回的数组长度就变成了对应长度的数组值

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-element
 

class Solution:

    def search(self, nums: List[int], target: int) -> int:

        n = len(nums)

        left, right = 0, n - 1

        

        while left <= right:

            middle = (left + right) // 2

            if target < nums[middle]:

                right = middle - 1

            elif target > nums[middle]:

                left = middle + 1

            else:

                return middle

        return -1

class Solution:

    def removeElement(self, nums: List[int], val: int) -> int:

        slow, fast = 0, 0

        n = len(nums)

        while fast < n:

            if nums[fast] != val:

                nums[slow] = nums[fast]

                slow += 1

            fast += 1

        return slow

5.滑动窗口机制，先从两个指针快指针找到满足条件的值后，慢指针移动一位，快指针重新找到新的满足条件的值(在慢指针前移一位时，从sum中减去nums[start])直到慢指针到n的位置（初始化ans = n+1）。return 0 if ans == n + 1 else ans等价于if xxx： return 0    else： return ans

class Solution:

    def minSubArrayLen(self, target: int, nums: List[int]) -> int:

        if not nums: return 0

        start, end, sum = 0, 0, 0

        n = len(nums)

        ans = n + 1

        while end < n:

            sum += nums[end]

            while sum >= target:

                ans = min(ans, end - start + 1)              

                sum -= nums[start]                      #start往后移动一位，此时sum也要减去已经加过的nums[start]值

                start += 1

            end += 1

        return 0 if ans == n + 1 else ans

6.初始化二位数组：matrix = [[0 for _ in range(n)] for _ in range(n)]，_只是一个占位符，用for是深拷贝。跑完整个循环后，分析不满足条件的点，原因可能是1时，本身就不满足while循环。

class Solution:

    def generateMatrix(self, n: int) -> List:

        #初始化正方形矩阵,_只是一个占位符，用for是深拷贝

        matrix = [[0 for _ in range(n)] for _ in range(n)]

        left, right, high, low = 0, n - 1, 0, n - 1

        number = 1

        while high < low and left < right:

            #从左到右

            for i in range(left, right):

                matrix[high][i] = number

                number += 1

            #从上到下

            for i in range(high, low):

                matrix[i][right] = number

                number += 1

            #从右到左,从right往left，差值为-1，right>left

            for i in range(right, left, -1):

                matrix[low][i] = number

                number += 1

            #从下到上,从low往high，差值为-1，low>high

            for i in range(low, high, -1):

                matrix[i][left] = number

                number += 1

            #循环一圈，缩小一圈 

            high += 1

            right -= 1

            low -= 1

            left += 1

        #当一共奇数圈时，给几何中心赋值,要在整个循坏外，当只有一个元素时用    

        if n % 2:

            matrix[n // 2][n // 2] = number 

        return matrix

7.设立傻瓜头结点主要目的是考虑到如果要删除头结点，让本来的头结点变为傻瓜头结点的next结点，删除结点方式cur.next = cur.next.next

class Solution:

    def removeElements(self, head: ListNode, val: int) -> ListNode:

        #新建一个链表结构dummy_head,令dummy_head.next == head

        #设立dummy_head是为了让head成为dummy_head.next，方便删除头结点

        dummy_head = ListNode(next = head)

        #cur和dummy_head指向相同的物理地址，一起变化

        cur = dummy_head

        while cur.next != None:

            if cur.next.val == val:

                cur.next = cur.next.next

            else:

                cur = cur.next

        #头结点为0，如果return dummy_head的话，会多一个0的值

        return dummy_head.next

另外：感谢Carl，给了很多思路和参考（包括做题顺序），感谢Krahets,K神的一些解析，例如二叉搜索树于双向链表的解析：力扣