面试题68

题目地址：https://leetcode-cn.com/problems/er-cha-shu-de-zui-jin-gong-gong-zu-xian-lcof/

题目描述

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

百度百科中最近公共祖先的定义为：“对于有根树 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。因为根据定义最近公共祖先节点可以为节点本身。

说明:

所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉树中。

解题思路

递归：题目类似于68 - I题，但两者又存在一定的差别，这道题目给出的是二叉树，而不是二叉搜索树，对于二叉搜索树，它是有序的，我们可以通过判断节点p和节点q的值与当前节点的值，来判断节点p和q是否在当前节点的左右子树。对于二叉树，我们采用递归来实现，即采用后序遍历递归查找节点p和节点q，遇到节点p和节点q时直接返回，当节点p和q在节点root两侧时，说明root是节点p和q的最近公共祖先，若root节点是节点p和节点q的最近公共祖先，情况只能有以下三种

• 节点p和节点q在root的左右子树中，并且是处于root的两侧；
• 如果p=root，则q在root的左或右子树中；
• 如果q=root，则p在root的左或右子树中；

递归左子树和右子树时，会产生4种不同的情况

• case1：节点left和right均为空，表示节点root的左右子树中均不包含节点p和q，即二叉树中未找到节点p和q；
• case2：节点p和节点q均不为空，表示节点p和节点q在节点root的两侧，即节点root为节点p和q的最近公共祖先；
• case3：left为空，right不为空时，表示节点p和节点q均不在节点root的左子树中，返回right，即在节点root的右子树中递归遍历查找，此时，需要注意的是，节点p和q是否均在节点root的右子树中，如果节点p和节点q都在root的右子树中，此时的right指向最近公共祖先节点，否则，right指向节点p或者q；
• case4：left不为空，right为空，与case3类似；

非递归：通过后序遍历，获取根节点到目标节点p和q的路径，然后再通过获取的路径，求的公共节点。我们利用栈来分别存放根节点到节点p和q之间的路径，最后一个相同的节点即为节点p和q的最近公共祖先节点。比如p=2，q=8，则根节点到节点p的路径为[3，5，2]，根节点到几点q的路径为[3，1，8]，我们发现最后一个相同节点就是3，所以节点3是节点2和节点8的最近公共祖先节点。

程序源码

递归

/**
 * 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:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root == nullptr || root == p || root == q) return root; //返回最近公共祖先节点
        TreeNode* left = lowestCommonAncestor(root->left, p, q); //递归左子树
        TreeNode* right = lowestCommonAncestor(root->right, p, q); //递归右子树
        if(left == nullptr && right == nullptr) return nullptr; //case1
        if(left == nullptr) return right; //case3
        if(right == nullptr) return left; //case4
        return root; //case2
    }
};

非递归（栈）

/**
 * 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:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
            vector<TreeNode*> path_p, path_q;
            node_path(root, p, path_p); //获取根节点root到节点p的路径
            node_path(root, q, path_q); //获取根节点root到节点q的路径
            TreeNode* node = nullptr; // 最近公共祖先节点
            int node_len = min(path_p.size(), path_q.size());
            for(int i = 0; i < node_len; i++)
            {
                if(path_p[i] != path_q[i]) return node;
                node = path_p[i];
            }
            return node;
    }
    void node_path(TreeNode* root, TreeNode* last, vector<TreeNode*>& path)
    {
        stack<TreeNode*> sk;
        TreeNode* cur = root, *prev = nullptr; //prev表示当前节点已被访问
        while(cur != nullptr || !sk.empty())
        {
            while(cur)
            {
                sk.push(cur);
                path.push_back(cur);
                if(cur == last) return;
                cur = cur->left; //遍历左子树
            }
            cur = sk.top();
            if(cur->right == nullptr || cur->right == prev)
            {
                path.pop_back(); //清空路径
                sk.pop();
                prev = cur;
                cur = nullptr;
            }
            else
            {
                cur = cur->right; //遍历右子树
            }
        }
    }
};