算法-二叉树-递归使用

递归思想：
递推：基于上一次进行下一次的执行
回溯：遇到终止条件，逐级返回

递归思路：自上而下的使用 先序遍历 ，先判断根节点，再左右递归。
自下而上的使用 后序遍历， 先左右递归，从左右节点返回。

一、求二叉树的最大深度：

class Solution:
    def maxDepth(self , root ):
        # write code here
        if not root:
            return 0  #注意该条件
        if not root.left and not root.right:
            return 1
        ml = self.maxDepth(root.left)+1
        mr = self.maxDepth(root.right)+1
        return max(ml, mr)

二、求二叉树的最小深度：

class Solution:
    def mDepth(self , root ):
        # write code here
        if not root:
            return 0  #注意该条件
        if not root.left and not root.right:
            return 1
        #与求最大深度不同的是左右子树有空的时候不能比较，否则会返回1    
        if not root.left:
            return self.minDepth(root.right)+1
       if not root.right:
           return self.minDepth(root.left)+1    
        ml = self.minDepth(root.left)+1
        mr = self.minDepth(root.right)+1
        return min(ml, mr)

三、判断平衡二叉树
输入一棵二叉树，判断该二叉树是否是平衡二叉树。
在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树
平衡二叉树（Balanced Binary Tree），具有以下性质：
它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树
解法：

class Solution:
    def getDepth(self, root):
        if not root:
            return 0
        if not root.left and not root.right:
            return 1
        lh = self.getDepth(root.left)+1
        rh = self.getDepth(root.right)+1
        if abs(lh-rh)>1 :
            return -1
        return max(lh, rh)
    
    def IsBalanced_Solution(self, pRoot):
        # write code here
        if not pRoot:
            return True
        if not pRoot.left and  pRoot.right:#判断只有右子树的情况
            return False
        if  pRoot.left and not pRoot.right:
            return False
        n = self.getDepth(pRoot)
        if n == -1:
            return False
        else:
            return True

四、在二叉树中找到两个节点的最近公共祖先
利用后序遍历，即左右根，通过左右子数是否包含目标节点去比较。
思想：
1、o1,o2分别在祖先左右两侧
2、祖先是o1，o2在祖先左/右侧
3、祖先是o2，o1在祖先左/右侧

class Solution:
    def dfs(self, root, o1, o2):
        if not root:
            return root
        if root.val == o1 or root.val == o2:
            return root
        left = self.dfs(root.left, o1, o2)  #遍历左子树
        right = self.dfs(root.right, o1, o2)	#遍历右子树
        if left and right: #o1和o2分布在左右子树
            return root
        if left:
            return left
        if right:
            return right
        
        
    def lowestCommonAncestor(self , root , o1 , o2 ):
        # write code here
        res = self.dfs(root, o1, o2)
        return res.val