68-普通二叉树的最近公共祖先

        给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”如输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1，输出: 3， 节点 5 和节点 1 的最近公共祖先是节点 3。

        对二叉树从下往上进行遍历。假设当前遍历的节点为temp节点，如果temp的左、右、本身均不包含p、q节点，则继续向上层循环。如果左子数包含p节点，右子树不包含q节点，则继续向上循环。直到某一个node节点，其左子数包含p节点，右子数包含q节点，则返回node即可；还有一种可能就是node节点本身就是q或这p节点，则node本身即为需要寻找的节点（即node的子节点包含p(q)，同时node是q(p)。

package leecodeOff;

import java.util.ArrayList;
import java.util.List;

/*
 * 68.二叉树的最近公共祖先
 */
public class Demo68_2 {
   
	
	/*
	 * 1.定义path_p,paht_q，用来记录遍历到该节点的路径
	 * 2.找到两个路径的第一个分叉节点
	 */
	
	//定义一个节点表示最深的公共祖先
	public TreeNode returnNode = null;
	
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    	boolean flag = dfs(root,p,q);
    	return returnNode;
    }
    
    public boolean dfs(TreeNode root,TreeNode p,TreeNode q) {
    	if(root == null) {
    		return false;
    	}
        boolean isleaf = dfs(root.left,p,q);
        boolean isright = dfs(root.right,p,q);
        /*
         * 1.左边包含p节点、右边包含q节点，即isleaf && isright == true，return root；
         * 2.左边包含p节点，右边不包括q节点，则isleaf = true，isright = false，需要继续遍历
         * 3.root为p或者q节点，同时包括另外一个节点，满足条件2
         */
        if(isleaf && isright) {
        	returnNode = root;
        }else if(root.val == p.val || root.val == q.val) {
        	if(isleaf || isright) {
        		returnNode = root;
        	}
        }
        //如果左、右、中有一个满足，则返回true
        return (isleaf || isright) ||(root.val == p.val || root.val == q.val);
    }
	
    public static void main(String args[]) {
    	Demo68_2 demo = new Demo68_2();
    	TreeNode node1 = new TreeNode(6);
		 TreeNode node21 = new TreeNode(2);
		 TreeNode node22 = new TreeNode(18);
		 TreeNode node31 = new TreeNode(0);
		 TreeNode node32 = new TreeNode(4);
		 TreeNode node33 = new TreeNode(7);
		 TreeNode node34 = new TreeNode(9);
		 TreeNode node51 = new TreeNode(3);
		 TreeNode node52 = new TreeNode(5);
		 node1.left = node21;
		 node1.right = node22;
		 node21.left = node31;
		 node21.right = node32;
		 node22.left = node33;
		 node22.right = node34;
		 node32.left = node51;
		 node32.right = node52;
		 TreeNode tempNode = demo.lowestCommonAncestor(node1, node32, node33);
		 TreeNode tempNode1 = demo.lowestCommonAncestor(node1, node32, node33);
		 System.out.println(tempNode.val);
		 System.out.println(tempNode1.val);
    }
    /*
     * 新方法
     */
    public TreeNode lowestCommonAncestorNew(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || p == root || q == root) {
            return root;
        }

        TreeNode l = lowestCommonAncestor(root.left, p, q);
        TreeNode r = lowestCommonAncestor(root.right, p, q);
    
        return l == null ? r : (r == null ? l : root);
    }
}