JAVA程序设计：二叉树的最近公共祖先（LeetCode：236）

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉树:  root = [3,5,1,6,2,0,8,null,null,7,4]

 

示例 1:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。
示例 2:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出: 5
解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。
 

说明:

所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉树中。

思路：

方法一：因为不想二叉搜索树那样每个节点的子树都是有一定规则的，因此我们可以考虑求出每个点的字典序，记录下每个点以及它包含子树起始和开始的位置，这样我们只用判断每个节点是否能"包进去"p节点和q节点即可。

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

class Solution {
	
    TreeNode ans=null;
	int len,cnt,maxdepth;
	Map<Integer,Integer> st=new HashMap();
	Map<Integer,Integer> ed=new HashMap();
	
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        len=0;cnt=0;maxdepth=0;
        dfs1(root,1);
        
        dfs2(root,1,p,q);
        
        return ans;
    }
    
    private void dfs2(TreeNode root,int depth,TreeNode p,TreeNode q)
    {
    	if(root==null)
    		return;
    	if(depth>maxdepth)
    	{
    		if(st.get(root.val)<=st.get(p.val) && ed.get(root.val)>=ed.get(p.val)
    				&& st.get(root.val)<=st.get(q.val) && ed.get(root.val)>=ed.get(q.val))
    		{
    			maxdepth=depth;
    			ans=root;
    		}
    	}
    	
    	dfs2(root.left,depth+1,p,q);
    	dfs2(root.right,depth+1,p,q);
    }
    
    private void dfs1(TreeNode root,int num)
    {
    	if(root==null)
    		return;
    	
    	st.put(root.val, ++cnt);
    	dfs1(root.left,num+1);
    	dfs1(root.right,num+1);
    	ed.put(root.val, cnt);
    }
}

方法二：常规递归遍历

从根节点开始遍历树。
如果当前节点本身是 p 或 q 中的一个，我们会将变量 mid 标记为 true，并继续搜索左右分支中的另一个节点。
如果左分支或右分支中的任何一个返回 true，则表示在下面找到了两个节点中的一个。
如果在遍历的任何点上，左、右或中三个标志中的任意两个变为 true，这意味着我们找到了节点 p 和 q 的最近公共祖先。

class Solution {
	
	private TreeNode ans;
	
	public Solution()
	{
		this.ans=null;
	}
	
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
       
        this.dfs(root, p, q);
        return ans;
    }
    
    private boolean dfs(TreeNode root,TreeNode p,TreeNode q)
    {
    	if(root==null)
    		return false;
    	
    	int left=dfs(root.left,p,q)==true?1:0;
    	int right=dfs(root.right,p,q)==true?1:0;
    	int mid=(root==p || root==q)==true?1:0;
    	
    	if(mid+left+right>=2)
    		this.ans=root;
    	
    	return (mid+left+right)>0;
    }
}

方法三：使用父指针迭代

从根节点开始遍历树。
在找到 p 和 q 之前，将父指针存储在字典中。
一旦我们找到了 p 和 q，我们就可以使用父亲字典获得 p 的所有祖先，并添加到一个称为祖先的集合中。
同样，我们遍历节点 q 的祖先。如果祖先存在于为 p 设置的祖先中，这意味着这是 p 和 q 之间的第一个共同祖先（同时向上遍历），因此这是 LCA 节点。

class Solution {
	
	Deque<TreeNode> stack =new ArrayDeque<>();
	Map<TreeNode,TreeNode>parent=new HashMap<>();
	
	
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    	parent.put(root, null);
    	stack.push(root);
    	
    	while(!parent.containsKey(p) || !parent.containsKey(q))
    	{
    		TreeNode node=stack.pop();
    		
    		if(node.left!=null)
    		{
    			parent.put(node.left, node);
    			stack.push(node.left);
    		}
    		if(node.right!=null)
    		{
    			parent.put(node.right, node);
    			stack.push(node.right);
    		}
    	}
    	
    	Set<TreeNode> ancestors=new HashSet();
    	
    	while(p!=null)
    	{
    		ancestors.add(p);
    		p=parent.get(p);
    	}
    	
    	while(!ancestors.contains(q))
    		q=parent.get(q);
    	
    	return q;
    }
}