最近公共祖先，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