最近公共祖先，lintcode

给定一棵二叉树，找到两个节点的最近公共父节点(LCA)。
最近公共祖先是两个节点的公共的祖先节点且具有最大深度。
注意事项
假设给出的两个节点都在树中存在

解题思路：采用分治的思想，递归的在左右子树中查找，如果跟节点不为空或者要查找的节点，继续递归查找。
一刷ac

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param root: The root of the binary search tree.
     * @param A and B: two nodes in a Binary.
     * @return: Return the least common ancestor(LCA) of the two nodes.
     */
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode A, TreeNode B) {
        if (root == null || root == A || root == B) return root;
        TreeNode findInLeft = lowestCommonAncestor(root.left, A, B);
        TreeNode findInRight = lowestCommonAncestor(root.right, A, B);
        if(findInLeft == null) return findInRight;
        if(findInRight == null) return findInLeft;
        return root;
    }
}

换一种dfs的方法，保存到达两个节点的路径，然后找到公公前缀最后一个位置就是公共祖先。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        List<TreeNode> l1 = new ArrayList<TreeNode>();
        List<TreeNode> l2 = new ArrayList<TreeNode>();
        dfs(root, p, l1);
        dfs(root, q, l2);
        int i = 1;
        TreeNode res = root;
        while(i < l1.size() && i < l2.size()){
            if(l1.get(i) == l2.get(i)){
                res = l1.get(i);
            }else{
                break;
            }
            i++;
        }
        return res;
    }
    public boolean dfs(TreeNode root, TreeNode node, List<TreeNode> l){
        if(root == null) return false;
        if(node == root){
            l.add(root);
            return true;
        }
        l.add(root);
        if(dfs(root.left, node, l)){
            return true;
        }
        if(dfs(root.right, node, l)){
            return true;
        }
        l.remove(l.size()-1);
        return false;
    }
}

还可以考虑用map＋queue