<p>Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.</p>

<p>According to the <a href="https://en.wikipedia.org/wiki/Lowest_common_ancestor" target="_blank">definition of LCA on Wikipedia</a>: &ldquo;The lowest common ancestor is defined between two nodes <code>p</code> and <code>q</code> as the lowest node in <code>T</code> that has both <code>p</code> and <code>q</code> as descendants (where we allow <b>a node to be a descendant of itself</b>).&rdquo;</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" />
<pre>
<strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
<strong>Output:</strong> 3
<strong>Explanation:</strong> The LCA of nodes 5 and 1 is 3.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2018/12/14/binarytree.png" style="width: 200px; height: 190px;" />
<pre>
<strong>Input:</strong> root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
<strong>Output:</strong> 5
<strong>Explanation:</strong> The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.
</pre>

<p><strong class="example">Example 3:</strong></p>

<pre>
<strong>Input:</strong> root = [1,2], p = 1, q = 2
<strong>Output:</strong> 1
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li>The number of nodes in the tree is in the range <code>[2, 10<sup>5</sup>]</code>.</li>
	<li><code>-10<sup>9</sup> &lt;= Node.val &lt;= 10<sup>9</sup></code></li>
	<li>All <code>Node.val</code> are <strong>unique</strong>.</li>
	<li><code>p != q</code></li>
	<li><code>p</code> and <code>q</code> will exist in the tree.</li>
</ul>

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

# class Solution:
#     def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
#         if(not root):
#             return None
#         if(root==p or root==q):
#             return root
#         leftLCA = self.lowestCommonAncestor(root.left, p, q)
#         rightLCA = self.lowestCommonAncestor(root.right, p, q)
 
        
#         if (leftLCA!= None and rightLCA!= None):
#             return root;
						
#         if (leftLCA!= None):
#             return leftLCA
        
#         return rightLCA





#Binary Tree Postorder Traversal:stack:=temp vector
#https://leetcode.com/problems/binary-tree-postorder-traversal/
class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':    

        cur, last = root, None
        pathp,pathq,temp=[],[],[]
        temp.append(cur)
        while not pathp or not pathq:
            cur=temp[-1]
            if temp[-1]==p:
                pathp=temp[:]
            if temp[-1]==q:
                pathq=temp[:]
            # standard post-order iterative tree traversal  
            if cur.left:
                temp.append(cur.left)
                cur.left=None
            elif cur.right:
                temp.append(cur.right)
                cur.right=None
            else:
                temp.pop()
        # compare paths and get lowest common ancestor
        n=min(len(pathp),len(pathq))
        for i in range(1,n):
            if pathp[i]!=pathq[i]:
                return pathp[i-1]
        return pathp[n-1]
18400