剑指 offer 86. 在二叉树中找到两个节点的最近公共祖先

给定一棵二叉树(保证非空)以及这棵树上的两个节点对应的val值 o1 和 o2，请找到 o1 和 o2 的最近公共祖先节点。

数据范围：树上节点数满足 1≤n≤10^5, 节点值val满足区间 [0,n)
要求：时间复杂度 O(n)

注：本题保证二叉树中每个节点的val值均不相同。

如当输入{3,5,1,6,2,0,8,#,#,7,4},5,1时，二叉树{3,5,1,6,2,0,8,#,#,7,4}如下图所示：

所以节点值为5和节点值为1的节点的最近公共祖先节点的节点值为3，所以对应的输出为3。
节点本身可以视为自己的祖先

示例1
输入：
{3,5,1,6,2,0,8,#,#,7,4},5,1
返回值：
3

示例2
输入：
{3,5,1,6,2,0,8,#,#,7,4},2,7
返回值：
2

一种非递归的思路是，遍历一次树(只要把两个结点都遍历到就 ok)，保存每个节点及其父节点的映射关系，这样就可以根据映射关系计算出最终结果。

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @param o1 int整型 
# @param o2 int整型 
# @return int整型
#
class Solution:
    def lowestCommonAncestor(self , root: TreeNode, o1: int, o2: int) -> int:
        # write code here
        a=dict()
        s = []
        s.append(root)
        a[root.val] = None
        while len(s)>0 and (not ((o1 in a) and (o2 in a))):
            temp = s.pop(0)
            if temp.left != None:
                a[temp.left.val] = temp
                s.append(temp.left)
            if temp.right != None:
                a[temp.right.val] = temp
                s.append(temp.right)
        b=dict()
        t = o1
        #b[o1] = 1
        while True:
            b[t] = 1
            father = a[t]
            if father != None:
                t = father.val
            else:
                break
        t = o2
        while True:
            if t in b:
                return t
            father = a[t]
            if father == None:
                break
            t = father.val
        return root.val
            

另一种方式是用递归的思路来计算：

def commonAncestor(self, root, o1, o2):
        if root == None or root.val == o1 or root.val == o2:
            return root
        left = self.commonAncestor(root.left, o1, o2)
        right = self.commonAncestor(root.right, o1, o2)
        if left == None:
            return right
        if right == None:
            return left
        return root
            
    def lowestCommonAncestor(self , root , o1 , o2 ):
        # write code here
        return self.commonAncestor(root, o1, o2).val