leetcode 236 二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉树:  root = [3,5,1,6,2,0,8,null,null,7,4]

 Java solution1 

  static  int BOTH_PENDING = 2;
    static  int LEFT_DONE = 1;
    static  int BOTH_DOWN = 0;
    public TreeNode lowestCommonAncestor1(TreeNode root, TreeNode p, TreeNode q) {
        Stack<Pair<TreeNode , Integer >>   stack = new Stack<>();
        stack.push(new Pair<TreeNode, Integer>(root, BOTH_PENDING));

        boolean one_node_found = false;
        TreeNode LCA = null;
        while(!stack.empty()){
            Pair<TreeNode, Integer> pair = stack.peek();
            TreeNode parentNode = pair.getKey();
            int      parentState = pair.getValue();
            if( parentState != BOTH_DOWN){
                TreeNode childNode ;
                if( parentState == BOTH_PENDING){
                    if( parentNode == p || parentNode == q){
                         if(one_node_found){
                               return LCA;
                         }
                         else{
                            one_node_found = true;
                            LCA = stack.peek().getKey();
                         }
                    }
                    childNode = parentNode.left;
                }
                else{
                    childNode = parentNode.right;
                }
                stack.pop();
                stack.push(new Pair<TreeNode, Integer>(parentNode, parentState -1 ));
                if(childNode != null){
                    stack.push(new Pair<TreeNode, Integer>(childNode, BOTH_PENDING));
                }
            }
            else{
               if(LCA == stack.pop().getKey() && one_node_found){
                   LCA = stack.peek().getKey();
               }
            }
        }
        return LCA;
    }

Java Solution2 

 public TreeNode lowestCommonAncestor2(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null){
            return root;
        }
        if(root == p || root == q){
            return root;
        }
        TreeNode  left = lowestCommonAncestor2(root.left , p,q);
        TreeNode  right = lowestCommonAncestor2(root.right, p, q);
        if(left !=null && right !=null){
            return root;
        }
        else if(left !=null){
            return left;
        }
        else if(right != null){
            return right;
        }
        return null;
    }

# Definition for a binary tree node.
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
# my solution
# class Solution:
#     def dfs(self, root: 'TreeNode', p: 'TreeNode' , stack: list) :
#         if( root == None):
#             return None
#         if(root == p ):
#             stack.append(root)
#             return True
#         ans = False
#         if( root.left != None):
#             stack.append(root)
#             ans = self.dfs(root.left,p,  stack)
#             if(not ans):
#                  stack.pop(-1)
#             else:
#                 return ans
#         if ( root.right != None):
#             stack.append(root)
#             ans = self.dfs(root.right,p,  stack)
#             if(not ans):
#                  stack.pop(-1)
#             else:
#                 return ans
#
#         return ans
#
#     def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
#         p_stack = []
#         self.dfs(root, p,p_stack)
#         q_stack = []
#         self.dfs(root, q,q_stack)
#
#         p_stack.reverse()
#         q_stack.reverse()
#         for i_node in p_stack:
#             for j_node in q_stack:
#                 if( i_node.val == j_node.val ):
#                     return i_node

# 方法一：递归
# class Solution:
#     def __init__(self):
#         self.ans = None
#
#     def lowestCommonAncestor(self, root, p, q):
#         def recurse_tree(current_node):
#             if not current_node:
#                 return False
#             left = recurse_tree( current_node.left)
#             right = recurse_tree( current_node.right)
#             mid = current_node == p or current_node == q
#             if( mid + left + right >= 2):
#                 self.ans = current_node
#             return mid or left or right
#         recurse_tree(root)
#         return self.ans

def pre_order_receverse(root : 'TreeNode'):
    stack = []
    pNode = root
    while( pNode != None or len(stack) > 0 ):
        if( pNode != None ):
            print(pNode.val)

            pNode =  pNode.left
        else:
            node = stack.pop()
            stack.append(pNode)
            pNode = node.right

def dfs_order_receverse(root : 'TreeNode'):
    stack = [root]
    # pNode = root
    while( len(stack) > 0 ):
        pNode = stack.pop(-1)
        print(pNode.val)
        if( pNode.right != None  ):
            stack.append(pNode.right)
        if( pNode.left != None  ):
            stack.append(pNode.left)

# 方法二：使用父指针迭代
# class Solution:
#     def lowestCommonAncestor(self, root, p, q):
#         stack = []
#         parent = {}
#         parent[root] = None
#         stack.append(root)
#         while p not in parent or q not in parent:
#             node = stack.pop(-1)
#             if(node.left ):
#                 parent[node.left] = node
#                 stack.append(node.left)
#             if(node.right):
#                 parent[node.right] = node
#                 stack.append(node.right)
#         ancestor = set()
#         while(p):
#             ancestor.add(p);
#             p = parent[p]
#         while( q not in ancestor):
#             q =  parent[q]
#         return  q

# 方法三 无父指针的迭代
class Solution:

    # Three static flags to keep track of post-order traversal.

    # Both left and right traversal pending for a node.
    # Indicates the nodes children are yet to be traversed.
    BOTH_PENDING = 2
    # Left traversal done.
    LEFT_DONE = 1
    # Both left and right traversal done for a node.
    # Indicates the node can be popped off the stack.
    BOTH_DONE = 0

    def lowestCommonAncestor(self, root, p, q):

        stack = [(root, Solution.BOTH_PENDING)]
        one_node_found = False
        LCA_index = -1
        while stack:
            parent_node, parent_state = stack[-1]
            if parent_state != Solution.BOTH_DONE:
                if parent_state == Solution.BOTH_PENDING:
                    if parent_node == p or parent_node == q:
                        if one_node_found:
                            return stack[LCA_index][0]
                        else:
                            one_node_found = True
                            LCA_index = len(stack) - 1
                    child_node = parent_node.left
                else:
                    child_node = parent_node.right
                stack.pop()
                stack.append((parent_node, parent_state - 1))
                if child_node:
                    stack.append((child_node, Solution.BOTH_PENDING))
            else:
                if one_node_found and LCA_index == len(stack) - 1:
                    LCA_index -= 1
                stack.pop()

        return None


if __name__ == '__main__':
    root = TreeNode(3)
    node1 = TreeNode(5)
    node2 = TreeNode(1)
    node3 = TreeNode(6)
    node4 = TreeNode(2)
    node5 = TreeNode(0)
    node6 = TreeNode(8)
    node7 = TreeNode(7)
    node8 = TreeNode(4)

    root.left = node1
    root.right = node2
    node1.left = node3
    node1.right = node4
    node2.left = node5
    node2.right = node6
    node4.left = node7
    node4.right = node8

    p = node1
    q = node2
    # dfs_order_receverse(root)
    print( Solution().lowestCommonAncestor(root, p, q).val )

 Java solution1