剑指Offer68-I.二叉搜索树的最近公共祖先 C++

news2024/10/7 6:44:34

1、题目描述

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

示例 1:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6
解释: 节点 2 和节点 8 的最近公共祖先是 6。
示例 2:
输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

2、VS2019上运行

方法一：两次遍历、递归的方法

#include <iostream>
#include <vector>

using namespace std;

// Definition for a binary tree node
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;

    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

class Solution {
public:
    // 获取从根节点到目标节点的路径
    vector<TreeNode*> getPath(TreeNode* root, TreeNode* target) {
        vector<TreeNode*> path;
        TreeNode* node = root;
        while (node != target) {
            path.push_back(node);//遍历到一个节点时，将该节点加入到路径path中
            if (target->val < node->val) {//利用二叉搜索树的特点：左子树小于节点
                node = node->left;
            }
            else {
                node = node->right;
            }
        }
        path.push_back(node);//把最后一个target的值加入到path路径中
        return path;
    }

    // 找到最近公共祖先
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        vector<TreeNode*> path_p = getPath(root, p);
        vector<TreeNode*> path_q = getPath(root, q);
        TreeNode* ancestor = nullptr;///用于保存最低公共祖先节点
        for (int i = 0; i < path_p.size() && i < path_q.size(); ++i) {
            if (path_p[i] == path_q[i]) {
                ancestor = path_p[i];
            }
            else {
                break;//如果有不相等的节点出现，那么这些节点之前的节点就是最低公共祖先节点的祖先。
            }
        }
        return ancestor;
    }
};

int main() {
    // Create the binary search tree
    TreeNode* root = new TreeNode(6);
    root->left = new TreeNode(2);
    root->right = new TreeNode(8);
    root->left->left = new TreeNode(0);
    root->left->right = new TreeNode(4);
    root->right->left = new TreeNode(7);
    root->right->right = new TreeNode(9);
    root->left->right->left = new TreeNode(3);
    root->left->right->right = new TreeNode(5);

    Solution solution;

    // Find the lowest common ancestor of nodes 2 and 4
    TreeNode* p = root->left;
    TreeNode* q = root->left->right;
    TreeNode* lca = solution.lowestCommonAncestor(root, p, q);

    cout << "Lowest Common Ancestor: " << lca->val << endl; // Output: 2

    // Remember to free the memory
    // ...

    return 0;
}

Lowest Common Ancestor: 2

3、解题思路

使用二叉搜索树的特性以及节点路径的比较来找到两个给定节点的最近公共祖先。
首先，我们定义了一个辅助函数 getPath，用于获取从根节点到目标节点的路径。在该函数中，我们从根节点开始遍历树，将经过的节点加入到路径中，直到遍历到目标节点为止。这个函数利用了二叉搜索树的特点，当目标节点的值小于当前节点的值时，我们向左子树移动；当目标节点的值大于当前节点的值时，我们向右子树移动。
接下来，我们定义了主函数 lowestCommonAncestor，用于找到给定两个节点的最近公共祖先。首先，我们分别调用 getPath 函数得到两个节点的路径。然后，我们从路径的开头开始，逐一比较路径中的节点，如果当前节点相同，那么这个节点就是最低公共祖先。一旦遇到路径中有节点不同的情况，就说明之前的节点是最低公共祖先的祖先节点，因此我们可以直接返回最低公共祖先。
总结起来，这个算法的思路是通过比较节点路径来找到最近公共祖先。首先获取从根节点到两个目标节点的路径，然后逐一比较路径中的节点，找到最低公共祖先节点。这个算法的时间复杂度是 O(N)，其中 N 是二叉搜索树中的节点数。

4、 path.push_back(node);

第一个：

path.push_back(node)这行代码是在getPath函数中，在每次遍历到一个节点时，将该节点加入到路径path中。
目的是为了将遍历过的节点按顺序保存下来，构成从根节点到目标节点的路径。通过将每个节点添加到path中，最后得到的path向量就是从根节点到目标节点的完整路径。
在遍历完成后，path向量中的最后一个元素就是目标节点本身，因为在遍历过程中，当节点等于目标节点时，也会将目标节点加入到path中

第二个：

循环结束后，我们已经找到了目标节点target，并将其添加到路径path中。但是，最后一个节点target还未添加到路径path中。
在当前的代码实现中，最后一个节点将是target节点，但是由于循环退出的条件是node != target，所以最后一次循环中node被更新为target，因此循环结束时node已经指向了目标节点。
为了将目标节点添加到路径path中，我们需要在循环结束后将其再次添加到path中，以保证路径的完整性。所以，代码中最后一行的path.push_back(node)的作用就是将目标节点target添加到路径path的末尾。