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 = -1;
            int q_index = -2;
            for (var i = 0; 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 >= 0 && q_index >= 0)
                {
                    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 = 0;
                int j = 0;
                while (i < l1.Count() && j < l2.Count())
                {
                    if (l1[i].val != l2[j].val)
                    {
                        return l1[i - 1];
                    }
                    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让我想起了日月生辉的光辉战斗机。