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;
	}

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