求二叉树的最近公共祖先算法 （java代码）

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。
例如图中的二叉树节点5，4的最近公共祖先是5。节点7，1的最近公共祖先是3。

算法一： 首先分别记录从两个子节点到根节点的路径存储在两个链表，然后这个问题可以转化为求两个链表的公共结点。

记录路径算法（递归）

public boolean getPath(List<TreeNode> list,TreeNode root,TreeNode p){ //返回p节点到根节点的路径
    boolean has = false;
     if(root == null) return has; 
     if(root == p){ //记录p节点
         has = true;
         list.add(root);
         return has;
     }
     has =  getPath(list,root.left,p) || getPath(list,root.right,p); //root是p节点的父节点
    if(has) list.add(root);
     return has;

}

记录路径算法（非递归）利用栈结构

public List getPath2(TreeNode root,TreeNode p){ //返回p节点到根节点的路径

    if(root==null) return null;
    List<TreeNode> list = new ArrayList<>();
    Stack<TreeNode> stack = new Stack<>();
    stack.push(root);
    int index = 0;
    while(index<stack.size() &&(root=stack.get(index))!=null){ //将整棵树压栈
        if(root.left!=null) stack.push(root.left);
        if(root.right!=null) stack.push(root.right);
        index++;
    }
    while(!stack.isEmpty()){
        root = stack.pop();
        if(root == p || root.left ==p || root.right == p){ //记录p节点到根节点的路径
            list.add(root);
            p = root;
        }

    }
    return list;
}

寻找两个链表的公共结点

public TreeNode getLastCommonNode(List<TreeNode> l1,List<TreeNode> l2){ //两个节点的路径
   int len = l1.size()-l2.size();
   TreeNode n1,n2;
   if(len>0){ //l1 比 l2长
       for (int i = 0; i < l2.size(); i++) {
           if(l1.get(len+i) ==l2.get(i)) return l2.get(i);
       }
   }else{ //l2 比 l1长
       for (int i = 0; i < l1.size(); i++) {
           if(l2.get(len-i) ==l1.get(i)) return l1.get(i);
       }
   }
   return null;
}

算法二： p,q节点的最近公共祖先root要满足一下三个条件之一：

1. p，q都在root的子树中，但不在root的同一侧子树（p在root的左子树q在root的右子树 或者相反）。因为如果p，q如果在root的同一侧子树，那么root的子节点应该才是p，q的最近公共祖先。
2. p == root q在 p 的左子树或者右子树。
3. q == root p在 q 的左子树或者右子树。

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    if(root == null || root == p || root == q) return root; //root为空，或者p，q有一个是根节点
    TreeNode left = lowestCommonAncestor(root.left, p, q); //p，q是否在root的左子树  
    TreeNode right = lowestCommonAncestor(root.right, p, q);//p，q是否在root的右子树  
    if(left == null) return right; 
    if(right == null) return left;
    return root;
}

1.如果 left ==null right ==null 代表root不是p,q的祖先节点
2.如果 left 和 right 其中一个为null代表 p,q 不分别在root的左右两侧，return 不为空的子树
3.如果 left 和 right都不为空，则 root 满足最近公共祖先的要求 return root

算法三： 与算法二相似，返回左右子树都为true的结点。

class Solution {
    TreeNode ans = null;
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {

        dfs(root,p,q);
        return ans;
    }

    public boolean dfs(TreeNode root, TreeNode p, TreeNode q){
        if(root == null) return false;
        boolean lson = dfs(root.left,p,q),rson =  dfs(root.right,p,q);
        if((lson&&rson) || (root == p ||root == q) &&(lson||rson))
            ans = root;
        return lson || rson || root == p || root == q;
    }

}

比较：
算法一 避免了重复判断，每个节点只判断一次。但是需要使用额外的数据结构链表。
算法二，三 存在节点重复判断，但是无需使用额外的空间，代码简洁。

算法二参考自链接：https://leetcode-cn.com/problems/er-cha-shu-de-zui-jin-gong-gong-zu-xian-lcof/solution/mian-shi-ti-68-ii-er-cha-shu-de-zui-jin-gong-gon-7/来源：力扣（LeetCode）作者：jyd
算法三参考自链接：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/solution/er-cha-shu-de-zui-jin-gong-gong-zu-xian-by-leetc-2/来源：力扣（LeetCode）作者：LeetCode-Solution