数据结构--树的最近公共祖先

情况1：当树是二叉搜索树时

首先判断两个节点值与当前节点的大小关系

若均大于当前节点值，则递归当前节点的右节点
若均小于当前节点值，则递归当前节点的左节点
否则，返回当前节点

 private TreeNode find(TreeNode node1, TreeNode node2, TreeNode root) {
        int val=root.value;
        if(val>node1.value && val>node2.value){
            return find(node1,node2,root.left);
        }
        if(val<node1.value && val<node2.value){
            return find(node1,node2,root.right);
        }
        return root;
    }

2. 普通二叉树：有指向父节点的指针

     	 可将其看成两个链表求公共节点的过程

 private TreeNode find(TreeNode node1, TreeNode node2) {

        int a=0， b=0;
        TreeNode nodea=node1;
        TreeNode nodeb=node2;
        while (node1!=null){
            node1=node1.parent;
            a++;
        }
        while(node2!=null){
            node2=node2.parent;
            b++;
        }
        if(a>b){
            for(int i=0;i<a-b;i++){
                nodea=nodea.parent;
            }
        }else if(b>a){
            for(int i=0;i<b-a;i++){
                nodeb=nodeb.parent;
            }
        }
        while (nodea!=null&&nodeb!=null){
            if(nodea==nodeb&&nodea.parent!=null){
                return nodeb;
            }
            nodea=nodea.parent;
            nodeb=nodeb.parent;
        }
        System.out.println("错误");
        System.exit(1);
        return null;
    }

3. 普通二叉树：无指向父节点的指针

    通过后置遍历的方式

class Solution {
    public TreeNode lowestAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null) return null;
        if(root == p) return p;
        if(root == q) return q;

        TreeNode left = lowestAncestor(root.left, p, q);
        TreeNode right = lowestAncestor(root.right, p, q);

        if(left != null && right != null)
            return root;
        return left == null ? right : left;
    }
}

4. N叉树的公共节点

public TreeNode1 lowestAncestor(TreeNode1 root, TreeNode1 p1, TreeNode1 p2) {
	LinkedList<TreeNode1> path1 = new LinkedList<TreeNode1>();
	LinkedList<TreeNode1> path2 = new LinkedList<TreeNode1>();
		
	getNodePath(root, p1, path1);
	getNodePath(root, p2, path2);
		
	if(path1.size() == 0 || path2.size() == 0)
		return null;
	return getLastCommonParent(path1, path2);
}
	
private boolean getNodePath(TreeNode1 root, TreeNode1 target,                                                              
                                            LinkedList<TreeNode1> path) {
	
	path.push(root);
	if(root == target) return true;
		
	boolean found = false;
	TreeNode1[] childs = root.childs;
	if(childs != null || childs.length > 0) {
		for(TreeNode1 child: childs) {
			if(found)  break;
			else   found = getNodePath(child, target, path);
		}
	}	
		
	if(!found)   
		path.pop();	
	return found;	
}
		
private static TreeNode1 getLastCommonParent(LinkedList<TreeNode1> p1,  
                                  LinkedList<TreeNode1> p2) {
	TreeNode1 tmp = null;
	for(int i = 0; i < p1.size(); i++) {
		if(p1.get(i) != p2.get(i))
			break;
		tmp = p1.get(i);
	}
	return tmp;
}