88 Lowest Common Ancestor of a Binary Tree

原题网址：https://www.lintcode.com/problem/lowest-common-ancestor-of-a-binary-tree/description

描述

给定一棵二叉树，找到两个节点的最近公共父节点(LCA)。

最近公共祖先是两个节点的公共的祖先节点且具有最大深度。

假设给出的两个节点都在树中存在

您在真实的面试中是否遇到过这个题？  是

样例

对于下面这棵二叉树

  4
 / 
3   7
   / 
  5   6

LCA(3, 5) = 4

LCA(5, 6) = 7

LCA(6, 7) = 7

标签

二叉树

LintCode 版权所有

 

 

思路：碰到二叉树问题基本上递归。这道题在递去过程中寻找A、B节点，一旦找到停止递归，进行回溯，回溯过程中找到最近公共父节点。

1.递去时，

递归终止条件为：若找到A或者B，当即返回该节点，若找不到返回NULL。

递归式，在左右子树中分别寻找。

2.回溯时，

若A、B在当前根节点左右两侧，那么当前根节点就是A、B的LCA，返回当前根节点；

若A，B在当前根节点的同一侧（left或right），那么另一侧的寻找结果为NULL。寻找结果不为NULL的那侧返回的节点，也就是最先找到的节点，即为A、B的LCA。

 

 

 

AC代码：

/**
 * 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 search 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) {
        // write your code here
    if (root==NULL||A==root||B==root)
    {
        return root;
    }
    TreeNode * left=lowestCommonAncestor(root->left,A,B);
    TreeNode * right=lowestCommonAncestor(root->right,A,B);
    if (left&&right)
    {
        return root;
    }
    else if (left)
    {
        return left;
    }
    else if(right)
    {
        return right;
    }
    else
    {
        return NULL;
    }
    
    }
};

 

参考：

LintCode：最近公共祖先  言简意赅

Lowest Common Ancestor  讲解详细，还提供了另外一种计数器的方法

[LintCode] Lowest Common Ancestor 最近公共祖先  两种方法

[LeetCode] Lowest Common Ancestor of a Binary Tree系列   总结了系列问题，普通二叉树LCA和二叉搜索树的LCA

 

 

思路2：用DFS求出顶点到A和B的路径，再从两条路径中找到第一个不相等的节点，则上一个节点即为LCA。参考：LintCode-最近公共祖先 

 

AC代码：

/**
 * 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 search 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) {
        // write your code here
    if (root==NULL)
    {
        return root;
    }
    vector<TreeNode*> cur;
    vector<TreeNode*> pathA;
    vector<TreeNode*> pathB;
    dfst(cur,root,A,B,pathA,pathB);
    TreeNode * result;
    for (int i=0;i<min(pathA.size(),pathB.size());i++)
    {
        if (pathA[i]==pathB[i])
        {
            result=pathA[i];//二者相同，赋值哪个都一样;
        }
        else
        {
            break;
        }
    }
    return result;
    }
    
    void dfst(vector<TreeNode*> cur,TreeNode * root, TreeNode * A, TreeNode * B,vector<TreeNode*> &pathA,vector<TreeNode*> &pathB)
{//注意cur不能加引用，其元素随着递归过程逐渐增多;而pathA和pathB必须为引用，否则值无法传递出去，这两数组相当于返回值;
    cur.push_back(root);
    if (root==A)
    {
        pathA=cur;
    }
    if (root==B)
    {
        pathB=cur;
    }
    if (root->left)
    {
        dfst(cur,root->left,A,B,pathA,pathB);
    }
    if (root->right)
    {
        dfst(cur,root->right,A,B,pathA,pathB);
    }
}
};