leetcode 235|236. Lowest Common Ancestor of a Tree

235. Lowest Common Ancestor of a Binary Search Tree

Given a binary search tree (BST), find the lowest common ancestor (LCA) of two given nodes in the BST.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”

        _______6______
       /              \
    ___2__          ___8__
   /      \        /      \
   0      _4       7       9
         /  \
         3   5

For example, the lowest common ancestor (LCA) of nodes 2 and 8 is 6. Another example is LCA of nodes 2 and 4 is 2, since a node can be a descendant of itself according to the LCA definition.

由于是二叉树，有个特点就是如果一个数比当前值大，另一个比当前值小，就肯定在左右两边。当前点肯定就是最小公共祖先。

/**
 * 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)
    {
        int minkey = min(p->val, q->val), maxkey = max(q->val, p->val);
        TreeNode * now = root;
        while (now)
        {
            if (now->val < minkey)
                now = now->right;
            else if (now->val > maxkey)
                now = now->left;
            else
                return now;
        }
        return nullptr;
    }
};

236. Lowest Common Ancestor of a Binary Tree

Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.

According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes v and w as the lowest node in T that has both v and w as descendants (where we allow a node to be a descendant of itself).”

        _______3______
       /              \
    ___5__          ___1__
   /      \        /      \
   6      _2       0       8
         /  \
         7   4

For example, the lowest common ancestor (LCA) of nodes 5 and 1 is 3. Another example is LCA of nodes 5 and 4 is 5, since a node can be a descendant of itself according to the LCA definition.

这个题是一般的二叉树。所以就先搜到root到要求点的两条路径。然后考察路径在哪不一样了。那就是最小公共祖先。

/**
 * 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)
    {
        //先DFS求到这两个节点的路径。
        vector<TreeNode*> routeP;
        helper(routeP, p, root);
        
        vector<TreeNode*> routeQ;
        helper(routeQ, q, root);
        
        //看这两个路径在哪不一样。之前那个就是公共路径。
        TreeNode* ret = nullptr;
        for (int i = 0; i < min(routeP.size(), routeQ.size()); i++)
        {
            if (routeP[i] == routeQ[i])
                ret = routeP[i];
            else
                break;
        }
        return ret;
    }
    
    bool helper(vector<TreeNode*> &route, TreeNode* target, TreeNode* now)
    {
        if (!now)
            return false;
        
        route.push_back(now);
        
        if (now == target)
        {
            return true;
        }
        
        if (helper(route, target, now->left) || helper(route, target, now->right))
            return true;
        
        route.pop_back();
        return false;
    }
};