LintCode 88: 88. Lowest Common Ancestor of a Binary Tree-优快云博客

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

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

原题如下：
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;
    }
};