Leetcode 236.二叉树的最近公共祖先

题目描述

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

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

示例一：

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

 示例二：

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

示例三：

 

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

示例四： 

输入：root = [1,2], p = 1, q = 2
输出：1

 这道题同样是一道经典的二叉树题目，具有很好的启发性和很好的递归价值，类似于找交点，但该题的难点

第一在于这颗二叉树是乱序的，不是搜索二叉树，不能通过判断值的大小来剪枝确定方向，而且题目给的是指针不能通过值的比较来查找节点同时不能排除一颗树中出现两个值相同的节点，也无法直接通过值的比较来查找。

第二在于树形结构没有parent父节点，所以我们无法在遍历的时候无法通过回溯知晓它的路径。

所以理论上只要解决或能规避以上两个问题，然后找出两个节点往前第一个共同的父节点就是最近的父节点了，结合题目来看有三种情况：

1、两个节点一个root的左子树，一个在右子树，这种情况下，最近的公共祖先就只能是根节点。

2、两个节点都在左或者都在根节点右或是都在左，最麻烦的情况，需要确定路径然后找出最近的公共祖先。

3、一个节点是另一个节点的祖先，直接返回该节点。

方法一：暴力搜索

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
//判断该路径中是否有目标节点，用于确定目标节点是在root的左还是右
    bool Istree(TreeNode* root,TreeNode* cur)
    {
        if(root==nullptr)
        return false;

        return root==cur
        ||Istree(root->left,cur)
        ||Istree(root->right,cur);//最终只要返回true就证明目标节点在此路径下
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) 
    {
        if(root==nullptr)//根为空直接返回
        return nullptr;

        if(root==p||root==q)//有一个是根节点就直接返回
        return root;

        //这里变量的创建是之后理清思路的关键，四个变量，p是否在左or右，q是否在左or右
        bool pleft,pright,qleft,qright;   

        pleft=Istree(root->left,p);//如果p在root左边就为true，不在就为false
        pright=!pleft;//直接和上面取反，如果在左那一定不在右，反之一定在右

        qleft=Istree(root->left,q);
        qright=!qleft;

        if((pleft&&qright)||(qleft&&pright))//如果一个在左一个在右直接返回root
        {
            return root;
        }
        else if(pleft&&qleft)//如果都在左直接去root的左边找
        {
            return lowestCommonAncestor(root->left,p,q);
        }
        else//如果在右直接去root右边找
        {
            return lowestCommonAncestor(root->right,p,q);
        }

    }
};

方法二：用stack 来记录和删除路径最后找出公共祖先

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    //结合stack前序遍历
    bool Istree(TreeNode* root,TreeNode* cur,stack<TreeNode*> &arr)
    {
        if(root==nullptr)//为空直接返回false
        return false;

        arr.push(root);//先插入该节点然后去它的左右子树找，如果没找到最后pop掉

        if(cur==root)//找到目标节点返回true
        return true;

        if(Istree(root->left,cur,arr))//去左子树找找到返回true
        return true;

        if(Istree(root->right,cur,arr))//去右子树找找到返回true
        return true;

        arr.pop();//左右都没找到直接pop然后返回false
        return false;
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) 
    {
        if(root==nullptr)
        return nullptr;

        if(root==p||root==q)
        return root;

        stack<TreeNode*> arr1,arr2;//创建stack栈
        Istree(root,p,arr1);//保留p和q的路径
        Istree(root,q,arr2);
       while(arr1.size()!=arr2.size())//让长的那个往上走和短的长度一致
       {
           if(arr1.size()>arr2.size())
           {
               arr1.pop();
           }
           if(arr2.size()>arr1.size())
           {
               arr2.pop();
           }
       }

       while(arr1.top()!=arr2.top())//找到第一个公共祖先
       {
           arr1.pop();
           arr2.pop();
       }

       return arr1.top();
    }
};