二叉树的层次遍历

二叉树的层次遍历

题目1:二叉树的层平均值

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组.

示例：
    3
   / \
  9  20
    /  \
   15   7
输出: [3, 14.5, 11]
解释:
第0层的平均值是 3,  第1层是 14.5, 第2层是 11. 因此返回 [3, 14.5, 11].

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/average-of-levels-in-binary-tree

**解法：需要借助队列来进行遍历，将 节点的左右子树依次放入队列，然后再从队列中取节点，当队列为空时遍历结束。**

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def averageOfLevels(self, root: TreeNode) -> List[float]:
        if not root:
            return []
        res = [] #记录结果
        level = [] #每层的节点值列表
        stack = [root] #初始化队列
        end =root #每层的边界节点（最右边节点）
        while stack:
            node = stack.pop(0) #取最左边的节点
            level.append(node.val)
            #如果该节点的左右子节点不为空时，依次加入到队列中
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
            #当节点是该层的最右边节点时，计算平均值
            if node == end:
                level_mean = sum(level)/len(level)
                res.append(level_mean)
                #对下一次循环的参数进行初始化               
                if stack:
                    end = stack[-1]#取下一层的最右边节点作为边界节点
                    level = []
        return res

题目2： 二叉树的所有路径

给定一个二叉树，返回所有从根节点到叶子节点的路径。

说明: 叶子节点是指没有子节点的节点。

示例:

输入:

   1
 /   \
2     3
 \
  5

输出: ["1->2->5", "1->3"]

解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3

解题思路：实质也是一道层次遍历的题目，只是让每个节点都携带其父节点的信息，这样当遍历到叶子结点时就能得到从根节点到该叶子结点上的路径。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
'''
借助队列，
'''
class Solution:
    def binaryTreePaths(self, root: TreeNode) -> List[str]:
        def helper(root):
            if not root:
                return []
            res = []
            stack = [[[root.val], root]] #初始化队列
            while stack:
                path, node = stack.pop(0)#从左边取一个节点出来
	             #如果是叶子结点，则将共根节点到该叶子结点上的路径信息保存到结果集res中
                if not node.left and not node.right:
                    path_str = "->".join([str(k) for k in path])
                    res.append(path_str)
                #否则，将左右子节点依次加入到队列中
                if node.left:
                    stack.append([path+[node.left.val], node.left]) #左节点
                if node.right:
                    stack.append([path+[node.right.val], node.right])
            return res 
        return helper(root)

题目3： 二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：

给定二叉树 [3,9,20,null,null,15,7]，

   3
  / \

  9  20

    /  \

   15   7

返回它的最大深度 3 

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def maxDepth(self, root: TreeNode) -> int:        
        if not root:
            return 0
        max_depth = 0
        depth_list = []
        stack = [[[root.val], root]]    
        while stack:
            path, node = stack.pop(0)
            if not node.left and not node.right:
                depth_list.append(path)
            if node.left:
                stack.append([path+[node.left.val], node.left])
            if node.right:
                stack.append([path+[node.right.val], node.right])
        max_depth = max([len(path) for path in depth_list])
        return max_depth

题目4：路径总和

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

 示例: 

给定如下二叉树，以及目标和 sum = 22，

 		 5
         / \
        4   8
       /   / \
      11  13  4
     /  \      \
    7    2      1
    
   返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def hasPathSum(self, root: TreeNode, sum_: int) -> bool:
        if not root:
            return False 
       
        stack = [[[root.val], root]]    
        while stack:
            path, node = stack.pop(0)
            if not node.left and not node.right:
                if sum(path)==sum_:
                    return True
            if node.left:
                stack.append([path+[node.left.val], node.left])
            if node.right:
                stack.append([path+[node.right.val], node.right])
        
        return False 

题目5： 二叉树的右视图

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例:

输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:

   1            <---
 /   \
2     3         <---
 \     \
  5     4       <---

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def rightSideView(self, root: TreeNode) -> List[int]:
        def helper(root):
            if not root:
                return []
            stack = [root]
            end = root
            level = []
            res = []
            while stack:
                node = stack.pop(0)
                level.append(node.val)
                if node.left:
                    stack.append(node.left)
                if node.right:
                    stack.append(node.right)
                if node == end:
                    res.append(level[-1])
                    if stack:
                        level = []
                        end = stack[-1]
            return res 
        return helper(root)