最近公共祖先 LCA 递归非递归

给定一棵二叉树，找到两个节点的最近公共父节点(LCA)。
最近公共祖先是两个节点的公共的祖先节点且具有最大深度。
假设给出的两个节点都在树中存在。

dfs递归写法

查找两个node的最近公共祖先，分三种情况：

1. 如果两个node在root的两边，那么最近公共祖先就是root。
2. 如果两个node在root的左边，那么把root的左子树作为root，再递归。
3. 如果两个node在root的右边，那么把root的右子树作为root，再递归。

深度优先遍历二叉树，一旦找到了两个节点其中的一个，就将这个几点返回给上一层，上一层节点通过判断其左右子树中是否恰好包含n1和n2两个节点，如果找到，对应的上一层节点肯定是所求的LCA；若果不是，将包括两个节点中任意一个的较低的节点返回给上一层，否则返回NULL。

 /**
  * 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 NULL;
         if(root==A || root==B)  return root;

         //递归寻找A B在左右子树的位置
         TreeNode* left = lowestCommonAncestor(root->left,A,B);
         TreeNode* right = lowestCommonAncestor(root->right,A,B);

         //如果A B分别位于root的两侧，则root是他们的LCA，否则是左子树或者右子树
         if(left&&right) return root;

         return left?left:right;

     }
 };

非递归：

后序遍历非递归

 TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
     if (root == nullptr)
         return root;
     stack<TreeNode*> s;
     vector<TreeNode*> vec; // p和q的公共祖先
     bool tag1 = false; // true:找到p
     bool tag2 = false; // true:找到q
     s.push(root);
     TreeNode* lastRoot = root;
     while (!s.empty()) // lastRoot(区分从左/右孩子返回)
     {
         root = s.top();
         if (root == p) {
             if(tag1 == false && tag2 == false)
                 vec.push_back(root);
             tag1 = true;
         }
         else if (root == q) {
             if (tag2 == false && tag1 == false)
                 vec.push_back(root);
             tag2 = true;
         }
         if (!tag1 && !tag2)
             vec.push_back(root); // 公共祖先入vector
         // 找到p,q并且root在公共祖先数组中
         if (tag1 && tag2 && find(vec.begin(), vec.end(), root) != vec.end())
             return root;
         // root的孩子节点还没访问
         if (lastRoot != root->right)
         {
             if (lastRoot != root->left) {
                 if (root->left != nullptr) {
                     s.push(root->left);
                     continue;
                 }
             }
             if (root->right != nullptr) {
                 s.push(root->right);
                 continue;
             }
         }
         // 孩子节点访问完，弹栈向上回溯
         lastRoot = root;
         s.pop();
     }
     return nullptr;
 }