leetcode236

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == NULL || root == p || root == q)
        {
            return root;
        }
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);
        if (left && right)
        {
            return root;
        }
        else
        {
            return left == NULL ? right : left;
        }
    }
};

补充一个DFS实现，使用先序遍历将每一个路径都记录下来，然后分情况讨论。

 public class Solution
     {
         List<List<TreeNode>> V = new List<List<TreeNode>>();
         Stack<TreeNode> v = new Stack<TreeNode>();

         public void PostTree(TreeNode node)
         {
             if (node != null)
             {
                 v.Push(node);
                 if (node.left != null)
                 {
                     PostTree(node.left);
                     v.Pop();
                 }
                 if (node.right != null)
                 {
                     PostTree(node.right);
                     v.Pop();
                 }
                 if (node.left == null && node.right == null)
                 {
                     var list = new List<TreeNode>();
                     foreach (var s in v)
                     {
                         list.Add(s);
                     }
                     list.Reverse();
                     V.Add(list);
                 }

             }
         }

         public TreeNode LowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q)
         {
             PostTree(root);
             int p_index = -;
             int q_index = -;
             for (var i = ; i < V.Count(); i++)
             {
                 if (V[i].Find(x => x.val == p.val) != null)
                 {
                     p_index = i;
                 }
                 if (V[i].Find(x => x.val == q.val) != null)
                 {
                     q_index = i;
                 }
                 if (p_index >=  && q_index >= )
                 {
                     break;
                 }
             }
             if (p_index == q_index)
             {
                 var l = V[p_index];
                 //p和q在同一个路径上
                 foreach (var va in l)
                 {
                     if (va.val == p.val || va.val == q.val)
                     {
                         return va;
                     }
                 }
             }
             else
             {
                 //p和q在不通路径上
                 var l1 = V[p_index];
                 var l2 = V[q_index];
                 int i = ;
                 int j = ;
                 while (i < l1.Count() && j < l2.Count())
                 {
                     if (l1[i].val != l2[j].val)
                     {
                         return l1[i - ];
                     }
                     i++;
                     j++;
                 }
             }
             return null;
         }
     }

补充一个python的实现：

 class Solution:
     #当p和q分别在某节点的左子树和右子树的时候，这个节点就是LCA
     def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
         if root == None or root == p or root == q:
             return root
         left = self.lowestCommonAncestor(root.left,p,q)#在左子树中找p或q
         right = self.lowestCommonAncestor(root.right,p,q)#在右子树中找p或q
         if left != None and right != None:#p和q分别在这个节点的左右子树，则当前节点就是LCA
             return root
         elif left != None:#p和q都在这个节点的左子树，则在p和q中，先被找到的就是LCA
             return left
         elif right != None:#p和q都在这个节点的右子树，则先被找到的就是LCA
             return right
         else:
             return None#p和q不在这个节点的子树中

LCA让我想起了日月生辉的光辉战斗机。