LeetCode Lowest Common Ancestor of a Binary Tree

题目：

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 v and w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”

_______3______
/              \
___5__          ___1__
/      \        /      \
6      _2       0       8
/  \
7   4

For example, the lowest common ancestor (LCA) of nodes 

5

 and 

1

 is 

3

.
Another example is LCA of nodes 

5

 and 

4

 is 

5

,
since a node can be a descendant of itself according to the LCA definition.
题意：
就是给定一棵二叉树和两个节点，然后求这两个节点的最近公共祖先。首先得明白这是如何实现的，LZ一开始想到方法是在《剑指Offer》中的，深度优先遍历树，从根节点到两个指定节点的路径，分别保存在list中，然后得到这两个list，就可以分别从头节点开始，找第一个相同的祖先就行，用栈来保存遍历的结果，并且得到的只要找到这个指定节点，就停止遍历。但是会出现栈溢出的情况。

public static TreeNode lowestCommonAncestor(TreeNode root,TreeNode p,TreeNode q)
{
Stack<TreeNode> path = new Stack<TreeNode>();
List<List<TreeNode>> result = new ArrayList<List<TreeNode>>();
path(root,p,path,result);
path.removeAllElements();
path(root,q,path,result);
System.out.println(result.size());
List<TreeNode> l1 = result.get(0);
List<TreeNode> l2 = result.get(1);
System.out.println(l1.size() + " " + l2.size());
int length = l1.size() < l2.size() ? l1.size() : l2.size();
System.out.println(length);
TreeNode node = null;
while(length-- > 0)
{
if(l1.get(length).val == l2.get(length).val)
{
node = l1.get(length);
break;
}
//length--;
}
System.out.println(node.val);
return node;
}
@SuppressWarnings("unchecked")
public static boolean path(TreeNode root,TreeNode node)
{

if(root == null) //返回false或者true的目的是为了只要找到相应的指定节点，就停止遍历
return false;
path.push(root);
if(root.val == node.val)
{
result.add((Stack<TreeNode>)(path.clone()));
return true;
}
if(path(root.left,node,path,result))
return true;
if(path(root.right,node,path,result))
return true;
path.pop(); //回溯，很典型
return false;
}}发现这种情况会出现栈溢出的情况，后来看了网上的一种算法，是采用递归来做，而且一看是非常简单的递归，非常简单明了。
public static TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q)
{
if(root == null)
return null;
if(root == p)
{
System.out.println(p.val);
return p;
}
if(root == q)
{
System.out.println(q.val);
return q;
}
TreeNode left = lowestCommonAncestor(root.left, p, q);
TreeNode right = lowestCommonAncestor(root.right, p, q);
if(left == null && right == null)
return null;
if(left != null && right == null)
{
System.out.println(left.val);
return left;
}
if(left == null && right != null)
{
System.out.println(right.val);
return right;
}
System.out.println(root.val);
return root;
}

深入理解，发现，这种方式非常简单，主要也是找相应的目的节点，然后找到后，就可以逐层返回到上一层，然后就是比较了。