题目
解题
限制1:所有节点的值都是唯一的。
限制2:p、q 为不同节点且均存在于给定的二叉树中。
以上两个限制可以简化求解:减少特殊情况的判断处理。
解题一
顺着一条 p 和 q 都在同一边的链子查找,也就是说:
- 若 p 和 q 都在某节点的左边,到左子树中查找共同祖先
- 若 p 和 q 都在某节点的右边,到右子树中查找共同祖先
- 若 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) O(N),空间复杂度为 O ( N ) 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) O(N),空间复杂度为 O ( N ) 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;
};