236. Lowest Common Ancestor of a Binary Tree. Sol

只需要遍历两次的解法

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

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”

Example 1:

Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
Output: 3
Explanation: The LCA of nodes 5 and 1 is 3.

Example 2:

Input: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
Output: 5
Explanation: The LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.

Example 3:

Input: root = [1,2], p = 1, q = 2
Output: 1

Constraints:

• The number of nodes in the tree is in the range [2, 105].
• -109 <= Node.val <= 109
• All Node.val are unique.
• p != q
• p and q will exist in the tree.

  class Solution(object):
      def preorder_left(self, root):
          node, output = root, []
          while node:  
              if not node.left:
                  output.append(node)
                  node = node.right 
              else: 
                  predecessor = node.left 
  
                  while predecessor.right and predecessor.right is not node: 
                      predecessor = predecessor.right 
  
                  if not predecessor.right:
                      output.append(node)
                      predecessor.right = node  
                      node = node.left  
                  else:
                      predecessor.right = None
                      node = node.right         
          return output   
      def preorder_right(self, root):
          node, output = root, []
          while node:  
              if not node.right: 
                  output.append(node)
                  node = node.left 
              else: 
                  predecessor = node.right
  
                  while predecessor.left and predecessor.left is not node: 
                      predecessor = predecessor.left 
  
                  if not predecessor.left:
                      output.append(node)
                      predecessor.left = node  
                      node = node.right  
                  else:
                      predecessor.left = None
                      node = node.left         
          return output
      
      def lowestCommonAncestor(self, root, p, q): 
          child_p = self.preorder_left(p)
          child_q = self.preorder_left(q)
          if q in child_p:
              return p
          elif p in child_q:
              return q
          else:
              output_l = self.preorder_left(root)
              output_r = self.preorder_right(root)
              l_p = output_l[:output_l.index(p)]
              r_p = output_r[:output_r.index(p)]
              prev_p = []
              for i in l_p:
                  if i in r_p:
                      prev_p.append(i)
              l_q = output_l[:output_l.index(q)]
              r_q = output_r[:output_r.index(q)]
              prev_q = []
              for j in l_q:
                  if j in r_q:
                      prev_q.append(j)
              output = []
              for k in prev_p:
                  if k in prev_q:
                      output.append(k)
              return output[-1]