LeetCode236 & 剑指Offer 68 - II 二叉树的最近公共祖先 &《程序员面试金典》面试题 04.08. 首个共同祖先

题目

解题

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

以上两个限制可以简化求解：减少特殊情况的判断处理。

解题一

顺着一条 p 和 q 都在同一边的链子查找，也就是说：

1. 若 p 和 q 都在某节点的左边，到左子树中查找共同祖先
2. 若 p 和 q 都在某节点的右边，到右子树中查找共同祖先
3. 若 p 和 q 不在同一边，root 为首个共同祖先

// javascript
var lowestCommonAncestor = function(root, p, q) {
	// 错误检查：有节点不在树中
	// 可删除：限制1 排除此种情况
    if (!covers(root, p) || !covers(root, q)) return null;
    return helper(root, p, q);
};

const helper = (root, p, q) => {
	// 一层一层向下找，如果 root 是 p / q，root 定为首个共同祖先
    if (root === null || root === p || root === q) return root;
    const pIsOnLeft = covers(root.left, p);
    const qIsOnLeft = covers(root.left, q);
    // 两个节点位于不同的两边：一个为 true，一个为 false
    // 不能写成 pIsOnLeft && qIsOnLeft === false，可能两个都是 false
    if (pIsOnLeft !== qIsOnLeft) return root;
    // 决定下一步是去 左 / 右子树寻找
    const next = (pIsOnLeft === true ? root.left : root.right);
    return helper(next, p, q);
};

const covers = (root, node) => {
    if (root === null) return false;
    return root === node || covers(root.left, node) || covers(root.right, node); 
};

尽管在运行时间上已经做到最优，还是可以看出部分操作效率低。特别是，covers 会搜索 root 下的所有节点以查找 p 和 q，包括每棵子树中的节点 (root.left 和 root.right)。 然后，它会选择那些子树中的一棵，搜遍它的所有节点，每棵子树都会被反复搜索。

解题二

后序遍历的深度优先搜索，解释可以去看官方剖析：首个共同祖先。下面的解答在官方基础下加了一个提前结束的判断条件。

// javascript
var lowestCommonAncestor = function(root, p, q) {
    let ans = null;
    const dfs = (root, p, q) => {
    	// ans !== null：ans找到，不用再找
        if (root === null || ans !== null) return false;
        const lson = dfs(root.left, p, q),
              rson = dfs(root.right, p, q);
        if (lson && rson || ((lson || rson) && (root === p || root === q))) {
            ans = root;
        }
        return lson || rson || root === p || root === q;
    };
    dfs(root, p, q);
    return ans;
};

时间复杂度为 $O(N)$，空间复杂度为 $O(N)$。

解题三

还有一个思路可以参考 首个共同祖先，注释详细，基于查找的判断方法，和上面递归不一样的地方主要是对 root = p / root = q 的判断位置。上面的解法一定是在确定找到 p 和 q 后才更新 ans 的，言外之意，但凡有一个节点没找到，结果都是 null。而下面的解法不然，以下图为例求解步骤如下：

lowestCommonAncestor(5, 3, 4)
	lowestCommonAncestor(3, 3, 4) -> 节点3
		root === p，返回 root 3
	lowestCommonAncestor(7, 3, 4) -> null
		没有找到 3 / 4
		lowestCommonAncestor(null, 3, 4)
		lowestCommonAncestor(8, 3, 4)

lowestCommonAncestor(3, 3, 4) 直接返回 节点3，lowestCommonAncestor(5, 3, 4) 发现左子树找到了一个节点，而右子树没有找到任何节点，基于题目给的 p 和 q 都在给定树里的限制，可以断定另一个没有被找到的节点在 节点3 的左 / 右子树里面。

但是如果题目没有给这样的限制，这个解法便会出错，假设寻找的是 p = 3, q = 9，左边返回节点3，右边返回 null，最终结果为节点3，但是其实节点9 根本不在以节点5 为根节点的树里，结果应该是 null，而上面的解法可以规避这一风险。

// javascript
var lowestCommonAncestor = function(root, p, q) {
    if (root === null || root === p || root === q) return root;
    const lson = lowestCommonAncestor(root.left, p, q),
          rson = lowestCommonAncestor(root.right, p, q);
    if (lson !== null && rson !== null) return root;
    return lson !== null ? lson : rson; 
};

时间复杂度为 $O(N)$，空间复杂度为 $O(N)$。

解题四：存储父节点

// javascript
var lowestCommonAncestor = function(root, p, q) {
    const fathers = new Map();
    const visited = new Set();
    const dfs = (root) => {
        if (root.left !== null) {
            fathers.set(root.left, root);
            dfs(root.left);
        }
        if (root.right !== null) {
            fathers.set(root.right, root);
            dfs(root.right);
        }
    };
    // 要首先把 root 的父亲设置为 null，否则下面两个 while 循环会变成无限循环
    fathers.set(root, null);
    dfs(root);
    while (p !== null) {
        visited.add(p);
        p = fathers.get(p);
    }
    while (q !== null) {
        if (visited.has(q)) return q;
        q = fathers.get(q);
    }
    return null;
};