leetcode102.二叉树的层次遍历、lc107.二叉树的层次遍历 II、lc111.二叉树的最小深度、lc559.N叉树的最大深度、lc199.二叉树的右视图

目录

 

题目一：leetcode102.二叉树的层次遍历

1.题目描述

2.解题思路

3.代码实现

题目二：leetcode107.二叉树的层次遍历 II

1.题目描述

2.解题思路

3.代码实现

题目三：leetcode111.二叉树的最小深度

1.题目描述

2.解题思路

3.代码实现

题目四：leetcode559.N叉树的最大深度

1.题目描述

2.解题思路

3.代码实现

题目五：leetcode199.二叉树的右视图

1.题目描述

2.解题思路

3.代码实现

---

题目一：leetcode102.二叉树的层次遍历

1.题目描述

给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。

例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

2.解题思路

方案一：利用队列层次遍历，每次遍历出队列表中的每一个节点，将这一整层的所有节点的左右节点作为下一层存入队列中。

方案二：还是利用队列层次遍历

现在需要2个变量，一个保存当前行的最右设为last，一个保存下一行的最右nlast

last刚开始为root，当前行即第一行，第一行最右即root

当访问cur时，把它加入tmp数组中，当访问cur的左右时，将左右节点加入队列不断更新nlast，从而保存下一行的最右节点

当访问到cur==last时，将这一行的结果tmp加入res中，并清空tmp：tmp = [ ]，且此时nlast必定已经迭代到下一行的最右了，所以在把nlast赋给last，进入下一行的访问。

3.代码实现

方案一：

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

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        q=[]
        q.append([root])
        res=[]
        while q:
            l=q.pop(-1)
            if not l:
                break
            ll=[]
            for i in l:
                ll.append(i.val)
            res.append(ll)
            tmp=[]
            for root in l:
                if root.left:
                    tmp.append(root.left)
                if root.right:
                    tmp.append(root.right)
            q.append(tmp)
        return res

方案二：

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

class Solution(object):
    def levelOrder(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        res = []
        last = root
        nlast = root
        que=[]
        que.append(root)
        tmp=[]
        while que:
            t = que.pop(0)
            tmp.append(t.val)
            if t.left:
                que.append(t.left)
                nlast = t.left
            if t.right:
                que.append(t.right)
                nlast = t.right
            if t == last:
                res.append(tmp)
                tmp=[]
                last = nlast
        return res

题目二：leetcode107.二叉树的层次遍历 II

1.题目描述

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

例如：
给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回其自底向上的层次遍历为：

[
  [15,7],
  [9,20],
  [3]
]

2.解题思路

把上一题的结果list反向即可

3.代码实现

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

class Solution(object):
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        if not root:
            return []
        res = []
        last = root
        nlast = root
        que=[]
        que.append(root)
        tmp=[]
        while que:
            t = que.pop(0)
            tmp.append(t.val)
            if t.left:
                que.append(t.left)
                nlast = t.left
            if t.right:
                que.append(t.right)
                nlast = t.right
            if t == last:
                res.append(tmp)
                tmp=[]
                last = nlast
        return res[::-1]

题目三：leetcode111.二叉树的最小深度

1.题目描述

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

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

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

示例:

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

    3
   / \
  9  20
    /  \
   15   7
返回它的最小深度  2.

2.解题思路

层次遍历，但是队列中存入的是当前节点和其高度，出队时，第一个不包含叶子节点的节点的高度即为二叉树的最小高度。

3.代码实现

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

class Solution(object):
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        last = root
        nlast = root
        que=[]
        level = 1
        que.append((root,level))
        while que:
            t,level = que.pop(0)
            if not t.left and not t.right:
                return level
            level+=1
            if t.left:
                que.append((t.left, level))
                nlast = t.left
            if t.right:
                que.append((t.right, level))
                nlast = t.right
            if t == last:
                last = nlast

题目四：leetcode559.N叉树的最大深度

1.题目描述

给定一个 N 叉树，找到其最大深度。

最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。

例如，给定一个 3叉树 :

我们应返回其最大深度，3。

说明:

树的深度不会超过 1000。
树的节点总不会超过 5000。

2.解题思路

和上面的题思路一样，层次遍历，最后出队的节点的level是这棵树的最大高度

3.代码实现

"""
# Definition for a Node.
class Node(object):
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""
class Solution(object):
    def maxDepth(self, root):
        """
        :type root: Node
        :rtype: int
        """
        if not root:
            return 0
        que=[]
        level = 1
        que.append((root,level))
        while que:
            t,level = que.pop(0)
            if t.children:
                level+=1
            for child in t.children:
                 que.append((child,level))
        return level

 

题目五：leetcode199.二叉树的右视图

1.题目描述

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

示例:

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

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

2.解题思路

使用层序遍历，并只保留每层最后一个节点的值

参考题目二

3.代码实现

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

class Solution(object):
    def rightSideView(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        if not root:
            return []
        res = []
        # 上一行最后一个节点
        last = root
        # 当前行最后一个节点
        nlast = root
        que=[]
        que.append(root)
        while que:
            t = que.pop(0)
            if t.left:
                que.append(t.left)
                nlast = t.left
            if t.right:
                que.append(t.right)
                nlast = t.right
            if t == last:
                # 把上一行的最后一个节点加入进来
                res.append(t.val)
                last = nlast
        return res