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

链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

题解：

中序遍历

/**
 *  * 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) {
            return nullptr;
        }
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);
        if(left && right) {
            return root;
        }
        if(root == p || root == q) {
            return root;
        }
        return left == nullptr ? right : left;
    }
};

1.前序遍历找到p，q的路径，并且存储

2.遍历存储的路径

/**
 * 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:
        bool find_node(TreeNode* root, TreeNode* p, vector<TreeNode*>* vec) {
            if (!root) {
                return false;
            }
            vec->push_back(root);
            if (root == p) {
                return true;
            }
            if (find_node(root->left, p, vec)) {
                return true;
            }
            if (find_node(root->right, p, vec)) {
                return true;
            }
            vec->pop_back();
            return false;
        }
        TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
            vector<TreeNode*> p_vec;
            find_node(root, p, &p_vec);
            vector<TreeNode*> q_vec;
            find_node(root, q, &q_vec);
            std::vector<TreeNode*>::iterator p_ite = p_vec.begin();
            std::vector<TreeNode*>::iterator q_ite = q_vec.begin();
            TreeNode* temp = nullptr;
            while(p_ite != p_vec.end() && q_ite != q_vec.end()) {
                if (*p_ite == *q_ite) {
                    temp = *p_ite;
                } else{
                    break;
                }
                ++p_ite;
                ++q_ite;
            }
            return temp;
        }
};

/**
 *  * 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:
    bool dfs(TreeNode* root, TreeNode* node, vector<TreeNode*>* path) {
        if(!root) return false;
        path->push_back(root);
        if(node == root) {
            return true;
        }
        if(dfs(root->left, node, path)) {
            return true;
        }
        if(dfs(root->right, node, path)) {
            return true;
        }
        path->pop_back();
        return false;
    }
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(!root) {
            return nullptr;
        }
        vector<TreeNode*> p1;
        dfs(root, p, &p1);
        vector<TreeNode*> p2;
        dfs(root, q, &p2);
        TreeNode* prev = nullptr;
        for(int i = 0, j = 0; i < p1.size() && j < p2.size(); ++i, ++j) {
            if(p1[i] != p2[j]) {
                break;
            }
            prev = p1[i];
        }
        return prev;
    }
};

/**
 * 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 {
class Result {
public:
    Result() {
        result = nullptr;
        is_valid = false;
    }
    Result(bool is_v, TreeNode* node) {
        result = node;
        is_valid = is_v;
    }
    bool is_valid;
    TreeNode* result;
};
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        Result res = calc(root, p, q);
        /*if (res.is_valid) {
            return res.result;
        }*/
        return res.result;
    }
private:
    Result calc(TreeNode* root, TreeNode* p, TreeNode* q) {
        Result res;
        // 如果当前节点为空节点直接返回
        if (!root) {
            return res;
        }

        Result left = calc(root->left, p, q);
        // 如果已经获得答案，则直接返回
        if (left.is_valid) {
            return left;
        }
        Result right = calc(root->right, p, q);
        // 如果已经获得答案，则直接返回
        if (right.is_valid) {
            return right;
        }
        // 左右都找到数值，则是当前root节点
        if (left.result && right.result) {
            return Result(true, root);
        }
        /* // 这里是特别判断，父亲节点为公共祖先的情况
        TreeNode* next = left.result != nullptr ? left.result : right.result;
        if (next) {
            if (p == root) {
                return Result(true, p);
            }
            if (q == root) {
                return Result(true, q);
            }
        }*/
        // 包含了父亲节点为公共祖先的情况，如果返回false，lowestCommonAncestor函数不能判断is_valid
        if (p == root) {
            return Result(false, p);
        }
        if (q == root) {
            return Result(false, q);
        }
        // 返回left和right中不为空的情况
        return left.result != nullptr ? left : right;
    }
};