最低公共祖先

最低公共祖先

方法一：递归实现

对于树中两个节点而言，最低公共祖先LCA其实就是该节点左边和右边分别包含A，B两个节点。只有A，B分别在其左右子树中。

1. 首先判断该节点是否非空，空返回NULL，表示既没有A，有没有B
2. 如果该节点本身是A，或者B中的一个则返回该节点
3. 递归的判断该节点的左右子树，如果左右子树都不是返回NULL，说明左右子树分别包含A，B那么就可以返回root。（注意，这是因为上面的如果分支中包含A，或者B，则一定不会返回NULL）
4. 如果不是root，那么必然是左子树或者右子树中非空的那一个。

/**
 * 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)return NULL;
        //节点本身已经是其中一个点那么就是root LCA
        if(root==A || root==B)return root;
        //
        TreeNode* left=lowestCommonAncestor(root->left,A,B);
        TreeNode* right=lowestCommonAncestor(root->right,A,B);
        if(left && right)return root;
        return left?left:right;
    }
};

最低公共祖先（包含父节点指针）

自底向上遍历直至根，问题转化为寻找两个链表的公共节点的问题，代码如下。

/**
 * Definition of ParentTreeNode:
 * class ParentTreeNode {
 * public:
 *     int val;
 *     ParentTreeNode *parent, *left, *right;
 * }
 */


class Solution {
public:
    /*
     * @param root: The root of the tree
     * @param A: node in the tree
     * @param B: node in the tree
     * @return: The lowest common ancestor of A and B
     */
    ParentTreeNode * lowestCommonAncestorII(ParentTreeNode * root, ParentTreeNode * A, ParentTreeNode * B) {
        // write your code here
        int na=0,nb=0;
        ParentTreeNode* tmpa=A;
        while(tmpa!=root){
            na++;
            tmpa=tmpa->parent;
        }
        ParentTreeNode* tmpb=B;
        while(tmpb!=root){
            nb++;
            tmpb=tmpb->parent;
        }
        int diff=abs(na-nb);
        ParentTreeNode* lnode=NULL;
        ParentTreeNode* snode=NULL;
        lnode=na>nb?A:B;
        if(lnode==A)
            snode=B;
        else
            snode=A;
        while(diff){
            lnode=lnode->parent;
            diff--;
        }
        while(lnode!=snode){
            lnode=lnode->parent;
            snode=snode->parent;
        }
        return lnode;
    }
};

最低公共祖先(两个节点可能一样，或者不是都存在)

1. 首先判断是否一样，一样直接返回，否则继续判断
2. 不一样则可以先采取一种遍历策略(本文选择中序遍历)计量是否都存在，如果不是都存在，返回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 tree.
     * @param A: A TreeNode
     * @param B: A TreeNode
     * @return: Return the LCA of the two nodes.
     */
    TreeNode * lowestCommonAncestor3(TreeNode * root, TreeNode * A, TreeNode * B) {
        // write your code here
        int findNums=0;
        postOrder(root,A,B,findNums);   //中序遍历一次，时间复杂度O(n)
        if(findNums==1 && A==B) //如果A，B代表同一个点
            return A;
        if(findNums!=2)         //两个点不是都存在，直接返回NULL
            return NULL;
        return LCA(root,A,B);   //两个点都存在，直接按照之前的方法处理即可。
    }
    void postOrder(TreeNode* root,TreeNode* A,TreeNode* B,int & findNums){
        if(!root)return;
        if(root==A || root==B){
            findNums++;
        }
        postOrder(root->left,A, B,findNums);
        postOrder(root->right, A, B,findNums);
    }

    TreeNode* LCA(TreeNode* root,TreeNode* A,TreeNode* B){
        if(!root)return NULL;
        if(root==A || root==B)return root;
        TreeNode* L=LCA(root->left,A,B);
        TreeNode* R=LCA(root->right,A,B);
        if(L && R)return root;
        return L?L:R;
    }
};