Leecode 236. 二叉树的最近公共祖先 DFS/递归

原题链接：Leecode 236. 二叉树的最近公共祖先


我的DFS。。。

/**
 * 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:
    vector<TreeNode* > v;
    vector<TreeNode* > v1;
    vector<TreeNode* > v2;
    void dfs(TreeNode* root, TreeNode* p,vector<TreeNode* > &vv)
    {
        if(root==p)
        {
            vv=v;
            vv.push_back(p);
            return;
        }
        if(root->left)
        {
            v.push_back(root->left);
            dfs(root->left,p,vv);
            v.pop_back();
        }
        if(root->right)
        {
            v.push_back(root->right);
            dfs(root->right,p,vv);
            v.pop_back();
        }
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        v.push_back(root);
        dfs(root,p,v1);
        v.clear();
        v.push_back(root);
        dfs(root,q,v2);
        int r=0;
        for(int i=0,j=0;i<v1.size(),j<v2.size();i++,j++)
        {
            if(v1[i]==v2[j]) r=i;
            else break;
        }
        return v1[r];
    }
};

递归

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

记录父亲节点

class Solution {
public:
    unordered_map<TreeNode*,TreeNode* > father;
    unordered_map<TreeNode*,int> m;
    void dfs(TreeNode* root)
    {
        if(root->left)
        {
            father[root->left]=root;
            dfs(root->left);
        }
        if(root->right)
        {
            father[root->right]=root;
            dfs(root->right);
        }
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        father[root]=NULL;
        dfs(root);
        while(p)
        {
           m[p]=1;
           p=father[p];
        }
        while(q)
        {
           if(m[q]) return q;
           q=father[q];
        }
        return NULL;
    }
};