leetcode刷题笔记-二叉树2

合并二叉树

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

输入: 
	Tree 1                     Tree 2                  
          1                         2                             
         / \                       / \                            
        3   2                     1   3                        
       /                           \   \                      
      5                             4   7                  
输出: 
合并后的树:
	     3
	    / \
	   4   5
	  / \   \ 
	 5   4   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 mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
        if t1==None and t2!=None:
            return t2    
        elif t1!=None and t2==None:
            return t1
        elif t1!=None and t2!=None:        
            t1.val = t1.val+t2.val
            t1.left=self.mergeTrees(t1.left,t2.left)
            t1.right=self.mergeTrees(t1.right,t2.right)
        return t1

此外，请注意在函数内部调用函数时，请使用self.mergeTrees这样的写法。

二叉树的最小深度

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

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

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

示例:

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

    3
   / \
  9  20
    /  \
   15   7

返回它的最小深度 2。

这道题需要自己讨论一下情况，主要是三种情况：
首先，叶子节点的定义是左孩子和右孩子都为 null 时叫做叶子节点。

1. 当 root 节点左右孩子都为空时，返回 1
2. 当 root 节点左右孩子有一个为空时，返回不为空的孩子节点的深度
3. 当 root 节点左右孩子都不为空时，返回左右孩子较小深度的节点值

合并三种情况为两种：

1. 当左右孩子为空时 root_left和root_right都为 0，可以和情况 2 进行合并，即返回 root_left+root_right+1
2. 当 root 节点左右孩子都不为空时，返回左右孩子较小深度的节点值

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

class Solution:
    def minDepth(self, root: TreeNode) -> int:
        if root==None: 
            return 0    
        root_left = self.minDepth(root.left)
        root_right = self.minDepth(root.right)
        #1.如果左孩子和右孩子有为空的情况，直接返回m1+m2+1
        #2.如果都不为空，返回较小深度+1
        if root.left==None or root.right==None:
            return root_left+root_right+1
        else:
            return min(root_left,root_right)+1

翻转二叉树

翻转一棵二叉树。
示例：
输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9

输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1

这道题仍然是递归的思想，具体表现在：

终止条件：当前节点为null时返回
交换当前节点的左右节点，再递归的交换当前节点的左节点，递归的交换当前节点的右节点

看代码：

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

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if root==None:
            return 0
        #将当前节点的左右子树交换
        root.right,root.left = root.left,root.right
        # 递归交换当前节点的 左子树和右子树
        self.invertTree(root.left)
        self.invertTree(root.right) 
        return root

对称的二叉树

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

    1
   / \
  2   2
 / \ / \
3  4 4  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 isSymmetric(self, root: TreeNode) -> bool:
        if root==None:
            return True
        def cmptree(left_tree,right_tree):
            if left_tree==None and right_tree==None:
                return True
            if left_tree==None or right_tree==None:
                return False
            if left_tree.val!=right_tree.val:
                return False
            return cmptree(left_tree.left,right_tree.right) and cmptree(left_tree.right,right_tree.left)     
        return cmptree(root.left,root.right)