【剑指offer】18.二叉搜索树的最近公共祖先

总目录：

算法之旅导航目录

 

1.问题描述

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

1.对于该题的最近的公共祖先定义:对于有根树T的两个节点p、q，最近公共祖先LCA(T,p,q)表示一个节点x，满足x是p和q的祖先且x的深度尽可能大。在这里，一个节点也可以是它自己的祖先.

2.二叉搜索树是若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值

3.所有节点的值都是唯一的。

4.p、q 为不同节点且均存在于给定的二叉搜索树中。

数据范围:

3<=节点总数<=10000

0<=节点值<=10000

 

2.问题分析

 1迭代，需要用上节点值的有序性，确定找到目标节点的路径，然后从头开始对比两条路径，找到最后一个共同点；

2递归，需要用上节点值的有序性，从根节点开始递归直到找到将两个目标值节点分流为左右两侧的节点；

3.代码实例

迭代

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 *  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @param p int整型
     * @param q int整型
     * @return int整型
     */
    vector<int> getPath(TreeNode* root, int tgtVal) {
        vector<int> vec;
        TreeNode* pCur = root;

        //深度搜索
        while (pCur != NULL) {
            //存储当前点
            vec.push_back(pCur->val);

            //如果当前点即为目标点，则中止搜索
            if (pCur->val == tgtVal) {
                break;
            }

            //根据当前点与目标值的大小比较决定取左还是右
            if (pCur->val > tgtVal) {
                pCur = pCur->left;
            } else {
                pCur = pCur->right;
            }
        }

        return vec;
    }
    int lowestCommonAncestor(TreeNode* root, int p, int q) {
        int tgtNodeVal = -1;

        vector<int> pathP = getPath(root, p);
        vector<int> pathQ = getPath(root, q);

        //从根节点开始遍历两条路径，直到发现不同点，取最后一个相同点
        for (int i = 0; i < pathP.size() && i < pathQ.size(); i++) {            
            if (pathP[i] != pathQ[i]) {
                break;
            }

            //记录当前相同点
            tgtNodeVal = pathP[i];
        }

        return tgtNodeVal;
    }
};

迭代得直接些

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 *  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @param p int整型
     * @param q int整型
     * @return int整型
     */
    int lowestCommonAncestor(TreeNode* root, int p, int q) {
        int tgtNodeVal = -1;
        TreeNode* pCur = root;

        while (pCur) {
            if (pCur->val > p && pCur->val > q) {
                pCur = pCur->left;
                continue;
            }
            if (pCur->val < p && pCur->val < q) {
                pCur = pCur->right;
                continue;
            }
            tgtNodeVal=pCur->val;
            break;
        }

        return tgtNodeVal;
    }
};

递归

/**
 * struct TreeNode {
 *  int val;
 *  struct TreeNode *left;
 *  struct TreeNode *right;
 *  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param root TreeNode类
     * @param p int整型
     * @param q int整型
     * @return int整型
     */
    int deltaRP;
    int deltaRQ;
    int lowestCommonAncestor(TreeNode* root, int p, int q) {
        int tgtNodeVal = -1;
        int deltaRP = root->val - p;
        int deltaRQ = root->val - q;

        //停止条件
        if (deltaRP * deltaRQ <= 0) {
            return root->val;
        }

        //根据差值符号选择左右方向
        root = deltaRP > 0 ? root->left : root->right;

        return lowestCommonAncestor(root,p,q);
    }
};