leetcode 235|236. Lowest Common Ancestor of a Tree

最新推荐文章于 2024-01-20 11:36:22 发布

原创最新推荐文章于 2024-01-20 11:36:22 发布 · 337 阅读

0 ·

CC 4.0 BY-SA版权

leetcode 专栏收录该内容

280 篇文章

订阅专栏

本文介绍在二叉搜索树和一般二叉树中寻找两个节点的最低公共祖先(LCA)的方法。针对二叉搜索树特性提出高效算法，并通过递归深度优先搜索解决一般二叉树问题。

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.

        _______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;
    }
};