LeetCode 236. 二叉树的最近公共祖先（java）

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

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

示例 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 。因为根据定义最近公共祖先节点可以为节点本身。
示例 3：

输入：root = [1,2], p = 1, q = 2
输出：1
 

提示：

树中节点数目在范围 [2, 105] 内。
-109 <= Node.val <= 109
所有 Node.val 互不相同 。
p != q
p 和 q 均存在于给定的二叉树中。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题解：

解法1

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public static boolean getPath(TreeNode root, TreeNode node, Stack<TreeNode> stack) {
        if (root == null || stack == null) return false;
        stack.push(root);
        if (root == node) return true;
        boolean flg = getPath(root.left, node, stack);
        if (flg) return true;
        flg = getPath(root.right, node, stack);
        if (flg) return true;
        stack.pop();
        return false;
    }
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null) return null;
        Stack<TreeNode> s1 = new Stack<>();
        getPath(root, p, s1);
        Stack<TreeNode> s2 = new Stack<>();
        getPath(root, q, s2);
        int size1 = s1.size();
        int size2 = s2.size();
        if (size1 - size2 >= 0) {
            int sub = size1 - size2;
            while (sub > 0) {
                s1.pop();
                sub--;
            }
            while (!s1.isEmpty() && !s2.isEmpty()) {
                if (s1.peek() == s2.peek()) {
                    return s1.peek();
                } else {
                    s1.pop();
                    s2.pop();
                }
            }
        } else {
            int sub = size2 - size1;
            while (sub > 0) {
                s2.pop();
                sub--;
            }
            while (!s1.isEmpty() && !s2.isEmpty()) {
                if (s1.peek() == s2.peek()) {
                    return s1.peek();
                } else {
                    s1.pop();
                    s2.pop();
                }
            }
        }
        return null;
    }
}

解法2

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null) return null;
        if (root == p || root == q) return root;
        TreeNode leftT = lowestCommonAncestor(root.left, p, q);
        TreeNode rightT = lowestCommonAncestor(root.right, p, q);
        if (leftT != null && rightT != null) return root;
        else if (leftT != null) return leftT;
        else return rightT;
    }
}