[leetcode日记]236.二叉树的最近公共祖先

题目

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x
的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]

示例 1:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出: 3 解释: 节点 5
和节点 1 的最近公共祖先是节点 3。 示例 2:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4 输出: 5 解释: 节点 5
和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

分析

这题应该算是一道经典老题了，我记得刚学树的结构的时候就遇到过这道题。这里有多种方法，题解区主要介绍两种，一种是基于递归的，一种是基于深度优先搜索的。我自己写了一种，基于路径搜索记录并比较两个节点的第一个分歧点的方法。

利用递归思想解决
1、如果root等于p或q，说明root本身就是最近公共祖先，直接返回
2、如果root为NULL则说明到了叶子节点，直接返回 3、分别查询左节点和右节点是否能够查到p或q
若p左q右，或p右q左，说明root就是最近公共祖先 若都在一边，那么只要继续查这一边就可以了

作者：realjimmy
链接：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/solution/236er-cha-shu-de-zui-jin-gong-gong-zu-xian-cdi-gui/
来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

基于递归 代码

struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    if (NULL == root || root == p || root == q)
        return root;

    struct TreeNode *left = lowestCommonAncestor(root->left, p, q);
    struct TreeNode *right = lowestCommonAncestor(root->right, p, q);

    if (NULL != left && NULL != right)
        return root;

    return NULL == left ? right : left;
}

作者：realjimmy
链接：https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/solution/236er-cha-shu-de-zui-jin-gong-gong-zu-xian-cdi-gui/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

运行结果

基于深度优先搜索代码

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
 struct TreeNode* pRes = NULL;
 int g_flag = 0;
 int dfs(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    int ret = 0;
    if(root == NULL) {
        return 0;
    }
    if (root->val == p->val) {
        ret += 1;
    }
    if (root->val == q->val) {
        ret += 1;
    }
    ret += dfs(root->left,p,q);
    ret += dfs(root->right,p,q);

    //左子树加上右子树加上根，第一返回2，证明找到了，就是结果。
    if (ret == 2 && g_flag == 0) {
       g_flag = 1;
       pRes = root;
    }
    return ret;
 }
struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    pRes = NULL;
    g_flag = 0;
    dfs(root,p,q);
    return pRes;  
}

运行结果

就效率来说，这题用递归的方法效率会更好。

比较路径，判断第一个分歧

这是第三种方法，我自己认为效率会不错。就是分别搜索两个节点，并记录它们的路径。比较两者的路径，并确定第一个分歧点，这个分歧点就是他们最近的公共父亲。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
#define MAX 100000
struct TreeNode* g_pathP[MAX];
struct TreeNode* g_pathQ[MAX];
int g_pcnt;
int g_qcnt;
int g_searchP;
void push(struct TreeNode* p)
{
    if (g_searchP) {
        g_pathP[g_pcnt] = p;
        g_pcnt++;
    } else {
        g_pathQ[g_qcnt] = p;
        g_qcnt++;
    }
    
}
void pop()
{
    if (g_searchP) {
        g_pcnt--;
        g_pathP[g_pcnt] = 0;
    } else {
        g_qcnt--;
        g_pathQ[g_qcnt] = 0;

    } 
}
int searchNode(struct TreeNode* root, struct TreeNode* p)
{
    push(root);
    if (root->val != p->val)
    {
        if (root->left != NULL) {
            if (searchNode(root->left, p))
            {
                return 1;
            }
            pop();
        }

        if (root->right != NULL) {
            if (searchNode(root->right, p))
            {
                return 1;
            }
            pop();
        }
    } else {
        return 1;
    }    
    return 0;
}
struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    g_qcnt = 0;
    g_pcnt = 0;
    g_searchP = 1;
    memset(g_pathP, 0, sizeof(struct TreeNode*) * MAX);
    memset(g_pathQ, 0, sizeof(struct TreeNode*) * MAX);

    searchNode(root, p);
    g_searchP = 0;
    searchNode(root, q);

    int i = 0;
    struct TreeNode* resptr;

    while (i >= 0) {
        if (g_pathP[i] != g_pathQ[i]) {
            break;
        }
        resptr = g_pathP[i];
        i++;
    }

    return resptr;
}

运行结果

让我很失望的是，运行结果并没有很理想。但是代码还有不少优化空间。

这道题目的这三种方法，都要好好地熟悉掌握！