leetcode打卡--面试题 04.06. 后继者

题目

题目描述：

设计一个算法，找出二叉搜索树中指定节点的“下一个”节点（也即中序后继）。

注意：

如果指定节点没有对应的“下一个”节点，则返回null。

示例 1:

示例2：

题目解析

• 就是找出二叉搜索树中序遍历情况下的下一个结点。

迭代法

思路：共分为两种情况

1. 如果该结点有右子树，则右子树中最小的结点就是下一个中序遍历的结点(由于中序遍历的顺序是从小到大有序的)。
2. 如果该结点没有右子树，则从跟结点往下走，求出这条路径下的大于该结点的值的最小值。

具体代码：
迭代实现一

class Solution {
public:
    TreeNode* FindMin(TreeNode* t ){
        if(t==nullptr)
        return nullptr;
        while(t->left)
        t = t->left;
        return t;
    }
    TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
        TreeNode* t = FindMin(p->right);
        //如果有右子树的情况
        if(p->right!=nullptr)
            return t;
        int cmp = p->val;
        TreeNode* tt = root;
        TreeNode* res=NULL;
        int cmp2 = INT_MAX;
        //如果没有右子树的情况，从上到下得出结果
        while(tt){
            if(tt==p)
                break;
            if(cmp<tt->val){
                if(tt->val<cmp2){
                    cmp2 = tt->val;
                    res = tt;
                }
                tt = tt->left;
            }else{
                if(tt->val>cmp&&tt->val<cmp2){
                    cmp2 = tt->val;
                    res = tt;
                }
                tt = tt->right;
            }    
        }
        return res;
    }
};

迭代实现二

• 由于二叉搜索树的左右子树特性，则找出距离p结点最近的，且p结点属于这个结点左侧的结点。

class Solution {
public:
    TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
        if (p->right) {//有右子树
            p = p->right;
            while (p->left) p = p->left;
            return p;
        }
        TreeNode* res = NULL;
        while (root != p) {//由于二叉搜索树的左右子树特性，则找出距离p结点最近的，且p结点属于这个结点左侧的结点
            if (root->val < p->val) {
                root = root->right;
            } else {
                res = root;
                root = root->left;
            }
        }
        return res;
    }
};

递归法

思路：有两种递归思路解法

1. 直接来个递归中序，用一共变量进行标记，如果碰到了p结点就标记一下为 true ，则下次的结点就是答案，再把标记赋值为 false 即可。
2. 根据之前第二种迭代的启发，我们可以在p为当前结点的左侧的时候对值进行更新(注意必须为压栈的后序更新，且更新条件为之前的返回值是否为空）。这个方法可以在脑海里对应一张关于递归树的图，从上往下，再从下往上，只更新从最下面往上第一个不为空的比 p->val 大的结点。

法一递归

class Solution {
public:
    TreeNode* res;
    bool f = false;
    TreeNode* p;
    TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
       this->p = p;
        dfs(root);
        return res;
    }
    void dfs(TreeNode* root){
        if(root==NULL)
            return;
        dfs(root->left);
        if(f){
            res = root;
            f = false;
            return;
        }
        if(root==p)
            f = true;
        dfs(root->right);
    }
};

法二递归

class Solution {
public:
    TreeNode* inorderSuccessor(TreeNode* root, TreeNode* p) {
        if (root == nullptr || p == nullptr) return nullptr;
        if (p->val >= root->val) {
            return inorderSuccessor(root->right, p);
        } else {
            TreeNode* left = inorderSuccessor(root->left, p);
            return left ? left : root;
        }
    }
};

应用范围

好了，我们能通过以上方法进行对二叉搜索树的中序的前一个结点和后一个结点进行快速定位(也就是从大到小的下一个结点)。

那么它有什么用呢？
只要是用过 C++ STL库的人应该都知道迭代器吧，而对于关系型容器的 set/map 都是用红黑树进行实现，而红黑树也是属于二叉搜索树，我们使用迭代器遍历它们的时候，发现，它就是遍历的二叉搜索树的中序遍历。

所以我在这里给出应用实例：set/map 的迭代器遍历实际上就是通过重载 ++ 和 -- 运算符实现迭代，而其中的 ++ 就是找出当前结点的后继者，-- 就是前驱者。