leetcode刷题02：二叉树层序遍历的应用（python实现）

二叉树层序遍历的应用

在编写层序遍历相关的习题时，其思想都和层序遍历类似，可以复用层序遍历的代码。

102. 二叉树的层序遍历

首先先回顾一下层序遍历的代码, 通过队列实现，每次获取节点的值时，将其子节点放入队列中。

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        
        queue, res = [root], []
        while queue:
            size = len(queue)
            temp = []
            for i in range(size):
                data = queue.pop(0)
                temp.append(data.val)
                if data.left:
                    queue.append(data.left)
                if data.right:
                    queue.append(data.right)
            res.append(temp)
        return res

接下来看一下其他习题。

199. 二叉树的右视图

如题，需要返回整棵树右边的值，所以，可以使用层序遍历，从右到左遍历，每行右边的第一个值就是该行右视图的值

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        
        queue, res = [root], []
        while queue:
            size = len(queue)
            temp = []
            for i in range(size):
                data = queue.pop(0)
                temp.append(data.val)
                if data.right:
                    queue.append(data.right)
                if data.left:
                    queue.append(data.left)
            res.append(temp[0])  # 取每行层次遍历从左到右的第一个值
        return res

222. 完全二叉树的节点个数

这道题可以使用递归，也可以利用层次遍历获取每个值的方法求得每一行的节点数，再累计求和

不过这道题使用递归比较简单.

层次遍历解法

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def countNodes(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        
        queue, res = [root], 0
        while queue:
            size = len(queue)
            temp = []
            for i in range(size):
                data = queue.pop(0)
                temp.append(data.val)
                if data.left:
                    queue.append(data.left)
                if data.right:
                    queue.append(data.right)
            res += len(temp)
        return res

递归解法

递归不用关心到底执行路径是什么，只关心一层的计算，然后将其递归自动计算每一层。

对于一棵只有三个节点的树来说：父节点，左子树节点，右子树节点

那么计算这棵树的节点总数办法就是左子树节点数 + 右子树节点数 + 父节点1

所以分别对左右子树递归，将其看作父节点，又可以求出下层的节点数

class Solution(object):
    def countNodes(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        
        return self.countNodes(root.left) + self.countNodes(root.right) + 1

429. N 叉树的层序遍历

N叉树与二叉树的不同在于可以有多个子节点，由于不区分左右子节点，所以可以把所有的子节点一次性入队列

稍微修改一下二叉树的层次遍历代码即可，只不过队列queue中不是存储单个节点，而是每个节点的子节点组成的列表

同时注意一下queue的初始化，父节点root就相当于只有一个子节点

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: Node
        :rtype: List[List[int]]
        """
        if not root:
            return []

        queue, res = [[root]], []
        while queue:
            size = len(queue)
            temp = []
            for i in range(size):
                data = queue.pop(0) # 节点列表
                for j in range(len(data)):
                    temp.append(data[j].val)
                    if data[j].children:
                        queue.append(data[j].children) # 节点拥有的子节点一起入队列
            res.append(temp)
        return res

513. 找树左下角的值

查找最后一层最左边的值。

比较好的方法是使用层序遍历，从右到左依次遍历每一行，取最后一个值

下面这个方法比较笨，老老实实从左向右遍历，取结果值的最后一个列表的第一个值。其实就是来一遍层序遍历，然后处理一下结果值

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def findBottomLeftValue(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return

        queue, result = [root], []
        while queue:
            size = len(queue)
            temp = []
            for i in range(size):
                data = queue.pop(0)
                temp.append(data.val)
                if data.left:
                    queue.append(data.left)
                if data.right:
                    queue.append(data.right)
            result.append(temp)
        return result[-1][0]

好办法就是从右向左遍历，整棵树遍历完之后，最后一个遍历的值就是要取的值。

甚至不用使用数组来存储，每次赋值给结果值res，最后一个值赋值完毕之后就返回了

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def findBottomLeftValue(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return
        
        queue, res = [root], 0
        while queue:
            data = queue.pop(0)
            res = data.val
            if data.right:
                queue.append(data.right)
            if data.left:
                queue.append(data.left)
        return res