LintCode 88: 88. Lowest Common Ancestor of a Binary Tree

原创已于 2023-10-28 00:52:34 修改 · 235 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LintCode

于 2018-12-07 16:59:07 首次发布

algorithm-design 专栏收录该内容

817 篇文章

订阅专栏

本文探讨了在二叉树中寻找两个节点的最低公共祖先（LCA）问题，提供了两种解决方案：一种通过记录路径，另一种采用递归方式。重点介绍了Labuladong的优秀模板。

原题如下：
88. Lowest Common Ancestor of a Binary Tree
Given the root and two nodes in a Binary Tree. Find the lowest common ancestor(LCA) of the two nodes.

The lowest common ancestor is the node with largest depth which is the ancestor of both nodes.

Example
For the following binary tree:

4
/
3 7
/
5 6
LCA(3, 5) = 4

LCA(5, 6) = 7

LCA(6, 7) = 7

Notice
Assume two nodes are exist in tree.

解法1：
注意是BT不是BST。

/**
 * Definition of TreeNode:
 * class TreeNode {
 * public:
 *     int val;
 *     TreeNode *left, *right;
 *     TreeNode(int val) {
 *         this->val = val;
 *         this->left = this->right = NULL;
 *     }
 * }
 */


class Solution {
public:
    /*
     * @param root: The root of the binary tree.
     * @param A: A TreeNode in a Binary.
     * @param B: A TreeNode in a Binary.
     * @return: Return the least common ancestor(LCA) of the two nodes.
     */
    TreeNode * lowestCommonAncestor(TreeNode * root, TreeNode * A, TreeNode * B) {
        TreeNode *resNode;
        vector<TreeNode *> path, pathA, pathB;
        helper(root, A, path, pathA);
        helper(root, B, path, pathB);

        int posA = 0, posB = 0;
        int lenA = pathA.size(), lenB = pathB.size();
        while (posA < lenA && posB < lenB && pathA[posA] == pathB[posB]) {
            resNode = pathA[posA];
            posA++;
            posB++;
        }
        return resNode;
    }
private:
    vector<TreeNode *> pathA, pathB;
    void helper(TreeNode *root, TreeNode *target, vector<TreeNode *> path, vector<TreeNode *> &finalPath) {
        if (root == target) {
            path.push_back(root);    
            finalPath = path;
            return;
        }
        if (!root) return;
        path.push_back(root);
        helper(root->left, target, path, finalPath);
        helper(root->right, target, path, finalPath);
    }
};

解法2：Labuladong的这个模板更好。


class Solution {
public:
    /*
     * @param root: The root of the binary tree.
     * @param A: A TreeNode in a Binary.
     * @param B: A TreeNode in a Binary.
     * @return: Return the least common ancestor(LCA) of the two nodes.
     */
    TreeNode * lowestCommonAncestor(TreeNode * root, TreeNode * A, TreeNode * B) {
        if (!root) return NULL;
        if (root == A || root == B) return root;
        TreeNode *left = lowestCommonAncestor(root->left, A, B);
        TreeNode *right = lowestCommonAncestor(root->right, A, B);
        if (left && right) return root;
        return left ? left : right;
    }
};