树 做题总结（二）[513,102,107,199,637] BFS

513. 找树左下角的值

思路：广度优先搜索，按层遍历，记录每层第一个，最后一层的第一个即为答案。两个条件，最左侧（第一个）和最后一层。
注意：迭代和递归两种都要掌握
代码：

class Solution:
    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        # 层序遍历迭代法
            # if not root:
            #     return 
            
            # from collections import deque
            # que = deque([root])      
            # while que:
            #     res = que[0]
            #     size = len(que)
            #     for _ in range(size):
            #         cur = que.popleft()
            #         if cur.left:
            #             que.append(cur.left)
            #         if cur.right:
            #             que.append(cur.right)
            #     if not que:
            #         return res.val
            
        res = []
        def bfs(root, depth):
            if not root: return []
            if len(res) == depth: res.append([]) # start the current depth
            res[depth].append(root.val) # fulfil the current depth
            if  root.left: bfs(root.left, depth + 1) 
            if  root.right: bfs(root.right, depth + 1)
        bfs(root, 0)
        return res[-1][0]

102/107. 二叉树的层序遍历

思路：
首先根元素入队
当队列不为空的时候
求当前队列的长度
依次从队列中取 s 个元素进行拓展，然后进入下一次迭代
注意：迭代和递归两种都要掌握
根节点–每一层–层中的每一个节点（判断左右孩子）
代码：

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        # 迭代
        # if not root:
        #     return []
        # results = []
        # from collections import deque
        # que = deque([root])
        # while que:
        #     result=[]
        #     for _ in  range(len(que)):
        #         cur = que.popleft()
        #         result.append(cur.val)
        #         if cur.left:
        #             que.append(cur.left)
        #         if cur.right:
        #             que.append(cur.right)
        #     results.append(result)
        # return results
        # 递归
        
        res=[]
        def bfs(root, depth):
            nonlocal res
            if not root: return []
            if len(res) == depth: 
                res.append([]) # start the current depth
            res[depth].append(root.val) # fulfil the current depth
            if  root.left: 
                bfs(root.left, depth + 1) # process child nodes for the next depth
            if  root.right: 
                bfs(root.right, depth + 1)
        bfs(root, 0)
        return res
		#与107的不同在于反向输出，自底向上
        return result[::-1]

199. 二叉树的右视图

思路：对二叉树进行层次遍历BFS，那么对于每层来说，最右边的结点一定是最后被遍历到的。二叉树的层次遍历可以用广度优先搜索实现。每次第一层遍历中取最后一个节点的val
注意：迭代和递归两种都要掌握
代码：

class Solution:
    def rightSideView(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        result = []
        from collections import deque
        collections 
        que = deque([root])
        while que:
            result.append(que[-1].val)
            for _ in  range(len(que)):
                cur = que.popleft()
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
        return result

637. 二叉树的层平均值

思路：对二叉树进行层次遍历BFS，对每层内所有节点求总和
注意：len(que)不固定，所以要令n=len(que), for _ in range(n)
代码：

class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        if not root:
            return []
        result=[]
        que = collections.deque([root])
        while que:
            summ=0
            n=len(que)

            for _ in range(n):
                cur = que.popleft()
                summ=summ+cur.val
                if cur.left:
                    que.append(cur.left)
                if cur.right:
                    que.append(cur.right)
            result.append(summ/n)
        return result