Leetcode 235. Lowest Common Ancestor of a Binary Search Tree

题目大意 : 给定一个排序二叉树, 以及二叉树中的两个结点, 寻找两个结点的祖先结点中, 层数最深的结点.

我的思路

首先第一步是寻找两个给定结点的相同的祖先结点, 然后再选择层次最深的. 可以用一个函数, 判断给定的两个结点是否相连, 然后就利用二叉树基本的层次遍历, 这样遍历到的最后一个祖先结点就肯定是层次最深的了. 代码如下 :

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        TreeNode result = root;
        while(!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode curr = queue.poll();
                if (isPath(curr, p) && isPath(curr, q))  result = curr;
                if (curr.left != null)   queue.add(curr.left);
                if (curr.right != null)  queue.add(curr.right);
            }
        }
        return result;
    }
    public boolean isPath(TreeNode parent, TreeNode child) {
        if (parent == null)
            return false;
        if (parent.left == child || parent.right == child || parent == child)
            return true;
        return isPath(parent.left, child) || isPath(parent.right, child);
    }
}

运行起来没什么问题, 但是很明显时间复杂度可能会比较大, 而且并没有利用到题目给定的二叉树是排序二叉树的特性.

大神思路

既然是一个二叉排序树, 那么其结点的值与其结点的位置关系就很大了.

用递归来实现, 假设当前结点为 curr, 给定的两个结点为 p 和 q, 其位置关系如下 :

1. 如果 curr.val < p.val && curr.val < q.val , 那么 p 和 q 一定在 curr 的右子树, 则其最深层的祖先结点也在 curr 右子树;
2. 同理, curr.val > p.val && curr.val > q.val, 那么 p 和 q 一定在 curr 的左子树, 则其最深层的祖先结点也在 curr 右子树;
3. 如果 p.val 和 q.val, 一个比 curr.val 大, 一个比 curr.val 小, 那么 p 和 q  都在其左右子树 , 则其最深层的祖先结点就是 curr;
4. 如果 p.val 或者 q.val, 和 curr.val 的值相等, 则其最深层的祖先结点就是 curr;

从上面的分类可以比较容易地得到递归函数 :

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root.val < p.val && root.val < q.val) {
            return lowestCommonAncestor(root.right, p, q);
        } else if (root.val > p.val && root.val > q.val) {
            return lowestCommonAncestor(root.left, p, q);
        } else {
            return root;
        }
    }
}

还有一种连比较都不需要的思路, 就真的是学习一下了 :

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || root == p || root == q)
            return root;
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if (left == null) return right;
        if (right == null) return left;
        return root;
    }
}

类似的题目是 Leetcode 236. Lowest Common Ancestor of a Binary Tree.