leetcode題目地址

二叉樹構造

TreeNode* t1 = new TreeNode(3);
    TreeNode* t2 = new TreeNode(5);
    TreeNode* t3 = new TreeNode(1);

    TreeNode* t4 = new TreeNode(6);
    TreeNode* t5 = new TreeNode(2);

    TreeNode* t6 = new TreeNode(0);
    TreeNode* t7 = new TreeNode(8);

    TreeNode* t8 = new TreeNode(7
 
);
    TreeNode* t9 = new TreeNode(4);

    t1->left = t2;
    t1->right = t3;

    t2->left = t4;
    t2->right = t5;

    t3->left = t6;
    t3->right = t7;

    t5->left = t8;
    t5->right = t9;

    TreeNode* root = t1;
    /*
        _______3______
       /              \
    ___5__          ___1__
   /      \        /      \
   6      _2       0       8
         /  \
         7   4
    */
 

AC1

使用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*> fa1;
    vector
 
<TreeNode*> fa2;

    void dfs(vector<TreeNode*> &fa, TreeNode* root, TreeNode* p, TreeNode* q)
    {
        if (root == NULL)
            return ;
        if (root == p){
            fa1 = fa;
        }
        if (root == q){
            fa2 = fa;
        }

        if (root->left != NULL){
            fa.push_back(root->left);
            dfs(fa,root->left, p,q);
            fa.pop_back();
        }
        if (root->right != NULL)
        {
            fa.push_back(root->right);
            dfs(fa, root->right, p,q);
            fa.pop_back();
        }
    }

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        vector<TreeNode*> fa;
        fa.push_back(root);
        dfs(fa, root, p,q);

        vector<TreeNode*>::iterator it1 = fa1.begin();
        vector<TreeNode*>::iterator it2 = fa2.begin();

        TreeNode* ans = NULL;;

        while (it1 != fa1.end() && it2 != fa2.end())
        {
            if (*it1 == *it2)
            {
                ans = *it1;
                it1++;
                it2++;
            }
            else{
                break;
            }
        }

        return ans;
    }
};

ac2

遍歷二叉樹時，只有先訪問給定兩節點A、B後，才可能確定其最近共同父節點C，因而採用後序遍歷。

可以統計任一節點的左右子樹“是否包含A、B中的某一個”（也可以直接統計“包含了幾個A、B”）。當後序遍歷訪問到某個節點D時，可得到三條資訊：（1）節點D是否是A、B兩節點之一、（2）其左子樹是否包含A、B兩節點之一、（3）其右子樹是否包含A、B兩節點之一。當三條資訊中有兩個為真時，就可以確定節點D的父節點（或節點D，如果允許一個節點是自身的父節點的話）就是節點A、B的最近共同父節點。另外，找到最近共同父節點C後應停止遍歷其它節點。

原文的程式碼似乎不符合，我重新改寫了一下程式碼，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:

    bool lca(TreeNode *root, TreeNode* va, TreeNode* vb, TreeNode *&result)  
    {  
        // left/right 左/右子樹是否含有要判斷的兩節點之一   
        bool left = false, right = false; 
        if (!result && root->left != NULL) 
            left = lca(root->left,va,vb,result);  
        if (!result && root->right != NULL) 
            right = lca(root->right,va,vb,result);  

        // mid 當前節點是否是要判斷的兩節點之一   
        bool mid = false;  
        if (root == va || root == vb) 
            mid = true;

        if (!result && int(left + right + mid) == 2) 
        {  
            result = root;// root就是後序遍歷（左，右，根），當前遍歷的那個節點
        }  
        return left | mid | right ;  
    }  

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q)
    {
        if (root == NULL) 
            return NULL;

        TreeNode *result = NULL;
        lca(root, p, q,result);  

        return result;  
    }
};