leetcode树之层级遍历应用

513、找树左下角的值

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。

假设二叉树中至少有一个节点。

示例1：

输入: root = [2,1,3]
输出: 1

示例2：

输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7

---

思路：

这道题需要找到最底层最左边节点的值，立马就想到层序遍历，然后取最后一层的第一个结点的值即可

class Solution:
    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        if not root: return -1
        queue = [root]
        ans = None
        while queue:
          	# 取层的第一个元素
            ans = queue[0].val
            for i in range(len(queue)):
                cur = queue.pop(0)
                if cur.left: queue.append(cur.left)
                if cur.right: queue.append(cur.right)
        return ans

515、在每个树行中找最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

示例1：

输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]

示例2：

输入: root = [1,2,3]
输出: [1,3]

---

思路：

题眼说要找到每一层的最大值，那很自然的想到要使用层序遍历

class Solution:
    def largestValues(self, root: Optional[TreeNode]) -> List[int]:
        if not root: return []
        queue = [root]
        ans = []
        while queue:
          	# 初始化每行的为无穷小
            level = float("-inf")
            for i in range(len(queue)):
                cur = queue.pop(0)
                if cur.left: queue.append(cur.left)
                if cur.right: queue.append(cur.right)
                # 
                level = max(level, cur.val)
            ans.append(level)
        return ans

这里可以稍微简写一下

from operator import attrgetter

class Solution:
    def largestValues(self, root: Optional[TreeNode]) -> List[int]:
        if not root: return []
        queue = [root]
        ans = []
        while queue:
          	# 这里通过key来比较queue里节点的val属性获得每层的最大值
            level = max(queue, key=attrgetter('val'))
            # 通过遍历获得下一层的节点
            queue = [n for node in queue for n in [node.left, node.right] if n]
            ans.append(level.val)
        return ans

623、在二叉树中增加一行

给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。

注意，根节点 root 位于深度 1 。

加法规则如下:

• 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。
• cur 原来的左子树应该是新的左子树根的左子树。
• cur 原来的右子树应该是新的右子树根的右子树。
• 如果 depth == 1 意味着 depth - 1 根本没有深度，那么创建一个树节点，值 val 作为整个原始树的新根，而原始树就是新根的左子树。

示例1：

输入: root = [4,2,6,3,1,5], val = 1, depth = 2
输出: [4,1,1,2,null,null,6,3,1,5]

示例2：

输入: root = [4,2,null,3,1], val = 1, depth = 3
输出:  [4,2,null,1,1,3,null,null,1]

---

思路：

看见深度，第一想法是层序遍历实现

class Solution:
    def addOneRow(self, root: TreeNode, val: int, depth: int) -> TreeNode:
      	# 如果depth为1，则将root作为插入值的左子树
        if depth == 1:
            return TreeNode(val, left=root)
        queue = [root]
        # level为下一层的depth
        level = 1
        while queue:
            level += 1
            for i in range(len(queue)):
                cur = queue.pop(0)
                # 这里判断level是否等于depth，如果是，则添加左右结点，否则继续层序遍历
                if level == depth:
                  	# 需要将其左右子树变更为插入值的左右子树
                    cur.left = TreeNode(val, left=cur.left)
                    cur.right = TreeNode(val, right=cur.right)
                elif level < depth:
                    if cur.left: queue.append(cur.left)
                    if cur.right: queue.append(cur.right)
        return root

这题也可以使用递归来解决

class Solution:
    def addOneRow(self, root: TreeNode, val: int, depth: int) -> TreeNode:
      	# 如果depth为1，直接将root作为根节点的左子节点
        if depth == 1:
            return TreeNode(val, left=root)
        def dfs(root, level):
            if not root: return
            next_level = level + 1
            # 如果下一层级为指定层级，那么设置root的左右结点，否则递归下一级
            if next_level > depth: return 
            if next_level == depth:
                root.left = TreeNode(val, left=root.left)
                root.right = TreeNode(val, right=root.right)
            else:
                dfs(root.left, next_level)
                dfs(root.right, next_level)
        dfs(root, 1)
        return root