树-二叉树的遍历问题

第一题：从上到下打印二叉树

link:https:https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-ii-lcof
describe：

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
例如:
给定二叉树: [3,9,20,null,null,15,7],

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

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

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

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        res, queue = [],[root]
        while queue:
            tmp=[]
            for _ in range(len(queue)):
                node = queue.pop(0)
                tmp.append(node.val)
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            res.append(tmp)
        return res

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        res, queue = [], collections.deque()
        queue.append(root)
        while queue:
            tmp = []
            for _ in range(len(queue)):
                node = queue.popleft()
                tmp.append(node.val)
                if node.left: queue.append(node.left)
                if node.right: queue.append(node.right)
            res.append(tmp)
        return res

第二题计算深度：

link:https://leetcode-cn.com/problems/er-cha-shu-de-shen-du-lcof
describe:
输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

例如：

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

    3
   / 
  9  20
    /  
   15   7
返回它的最大深度 3 。

方式一：
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        leftnode=self.maxDepth(root.left)
        rightnode=self.maxDepth(root.right)
        return max(leftnode,rightnode)+1
        
方式二：
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        queue,res = [root],0
        if not root:
            return 0
        while queue:
            tmp=[]
            for node in queue:
                if node.left:
                   tmp.append(node.left)
                if  node.right:
                    tmp.append(node.right)
            queue=tmp
            res +=1
        return res

方式三：
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root :
            return 0
        stack = [(root,1)]
        while stack:
            (node,level)=stack.pop(0)
            if node.left:
                
                stack.append((node.left,level+1))
                
            if node.right:
                stack.append((node.right,level+1))
        return level
        

第三题：层次遍历

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

 

示例：
二叉树：[3,9,20,null,null,15,7]

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

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

class Solution(object):
    def levelOrder(self, root):
        if not root:return []
        res = []
        queue = [root]
        while queue:
            # 获取当前队列的长度，这个长度相当于 当前这一层的节点个数
            size = len(queue)
            tmp = []
            # 将队列中的元素都拿出来(也就是获取这一层的节点)，放到临时list中
            # 如果节点的左/右子树不为空，也放入队列中
            for _ in range(size):
                r = queue.pop(0)
                tmp.append(r.val)
                if r.left:
                    queue.append(r.left)
                if r.right:
                    queue.append(r.right)
            # 将临时list加入最终返回结果中
            res.append(tmp)
        return res


class Solution(object):
    def levelOrder(self, root):

        if not root:
            return []
        res = []
        def dfs(index,r):
            # 假设res是[ [1],[2,3] ]， index是3，就再插入一个空list放到res中
            if len(res)<index:
                res.append([])
            # res是[ [1],[2,3] [4] ]，加入后res就变为 [ [1],[2,3] [4,99] ]
            res[index-1].append(r.val)
            # 递归的处理左子树，右子树，同时将层数index+1
            if r.left:
                dfs(index+1,r.left)
            if r.right:
                dfs(index+1,r.right)
        dfs(1,root)
        return res

 第四题：搜索二叉树的第n最大节点问题：

给定一棵二叉搜索树，请找出其中第k大的节点。

示例 1:

输入: root = [3,1,4,null,2], k = 1
   3
  / 
 1   4
  
   2
输出: 4
示例 2:

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

class Solution:
    def kthLargest(self, root: TreeNode, k: int) -> int:
        def helper(root):
            return helper(root.left) + [root.val] + helper(root.right) if root else []
        return helper(root)[-k]

第五题：平衡二叉树的判断

link:https://leetcode-cn.com/problems/ping-heng-er-cha-shu-lcof/
describe：
输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

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

    3
   / 
  9  20
    /  
   15   7
返回 true 。

示例 2:
给定二叉树 [1,2,2,3,3,null,null,4,4]

       1
      / 
     2   2
    / 
   3   3
  / 
 4   4
返回 false 。

class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        return self.treeHeight(root)>=0
    def treeHeight(self,root):
        if not root:
            return 0
        leftHeight=self.treeHeight(root.left)
        rightHeight=self.treeHeight(root.right)
        if leftHeight>=0 and rightHeight>=0 and abs(leftHeight-rightHeight)<=1:
            return max(leftHeight,rightHeight)+1
        else:
            return -1