【leetcode/二叉树】二叉树的最近公共祖先（递归+找节点路径）

问题描述：

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

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

我的基本思路：

找到给定节点到根节点的路径，比较最后相同的元素即可。

这两个部分：

·找到给定节点到根节点的路径

1.  递归使用布尔函数，用一个栈来存放路径（可以是输出参数或者是全局变量）
2.  先把节点入栈，查看左右节点是否能找到给定节点（这就是为什么要引入布尔函数），找不到就把当前节点出栈。

·比较数组中最后一对相同的元素

没啥好想的，暴力比较就完了

AC代码：

/**
 * 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<TreeNode *> s1, s2;    // 用来保存路径的栈
    bool FindPath(TreeNode *root, TreeNode *target, stack<TreeNode *> &s) {
      // 递归终止条件——没找到
      if (root == NULL) return false;
      s.push(root);
      // 递归终止条件——找到了
      if (root == target) return true;
      // 在左右子树中寻找
      // 短路运算使我们左边找到了就不找右边的了
      bool is_find = FindPath(root->left, target, s) || FindPath(root->right, target, s);
      if (!is_find) { s.pop(); }
      return is_find;
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
      // s1和s2存储了从节点到根节点的路径
      FindPath(root, p, s1);  
      FindPath(root, q, s2);
      // 寻找最后一对相同的元素
      vector<TreeNode *> v1;
      while (!s1.empty()) {
        auto heap = s1.top();
        s1.pop();
        v1.push_back(heap);
      }
      while (!s2.empty()) {
        auto heap = s2.top();
        s2.pop();
        if (find(v1.begin(), v1.end(), heap) != v1.end()) {
          return heap;
        }
      }
      return NULL;
    }
};

更加简便的做法：

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (!root || root == p || root == q) return root;
        auto left = lowestCommonAncestor(root->left, p, q);
        auto right = lowestCommonAncestor(root->right, p, q);
        if (!left) return right;
        if (!right) return left;

        return root;
    }
};

这个思路也很清晰了。。。自己瞅把