LeetCode Lowest Common Ancestor of a Binary Tree

Description:

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.

Solution:

LCA的解法有很多，但是这里又是一个没有数据范围的题目……( ▼-▼ )

比较优雅的做法是用后序遍历将两个节点p和q的祖先点都找到，然后找最后一个相同祖先节点就是LCA

注：后序遍历可以用于输出祖先节点

<span style="font-size:18px;">import java.util.*;

public class Solution {
	public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
		LinkedList<TreeNode> n1 = dfs(root, p, new LinkedList<TreeNode>());
		LinkedList<TreeNode> n2 = dfs(root, q, new LinkedList<TreeNode>());

		TreeNode lca = root;
		int n = Math.min(n1.size(), n2.size());
		for (int i = 0; i < n; i++) {
			if (n1.get(i) == n2.get(i))
				lca = n1.get(i);
			else
				return lca;
		}

		return lca;
	}

	public LinkedList<TreeNode> dfs(TreeNode root, TreeNode target,
			LinkedList<TreeNode> list) {
		if (root == null)
			return null;
		list.add(root);
		if (root == target)
			return list;
		LinkedList<TreeNode> node;
		node = dfs(root.left, target, list);
		if (node != null)
			return list;
		node = dfs(root.right, target, list);
		if (node != null)
			return list;
		list.remove(root);
		return null;
	}

	public static void main(String[] args) {
		Solution s = new Solution();

		TreeNode n1 = new TreeNode(1);
		TreeNode n2 = new TreeNode(2);
		TreeNode n3 = new TreeNode(3);
		TreeNode n4 = new TreeNode(4);
		TreeNode n5 = new TreeNode(5);
		TreeNode n6 = new TreeNode(6);
		n1.left = n2;
		n2.left = n4;
		n2.right = n5;
		n1.right = n3;
		n3.right = n6;

		System.out.println(s.lowestCommonAncestor(n1, n5, n2));
	}
}</span>