LintCode 448. Inorder Successor in BST

原创已于 2023-11-26 09:23:11 修改 · 300 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LintCode

于 2019-05-05 08:12:34 首次发布

algorithm-design 专栏收录该内容

817 篇文章

订阅专栏

本文围绕二叉搜索树中给定节点的中序后继展开，给出示例说明查找情况。还介绍了三种解法，包括二分查找（时间复杂度O(logn)）、递归写法以及通用的二叉树中序遍历，其中通用遍历未利用BST有序性质。

Inorder Successor in BST
中文English
Given a binary search tree (See Definition) and a node in it, find the in-order successor of that node in the BST.

If the given node has no in-order successor in the tree, return null.

Example
Example 1:

Input: tree = {1,#,2}, node value = 1
Output: 2
Explanation:
1

2
Example 2:

Input: tree = {2,1,3}, node value = 1
Output: 2
Explanation:
2
/
1 3
Binary Tree Representation

Challenge
O(h), where h is the height of the BST.

Notice
It’s guaranteed p is one node in the given tree. (You can directly compare the memory address to find p)

解法1：Binary Search。时间复杂度O(logn)。
注意：二分查找的顺序和中序遍历的顺序不一样！！！！！
代码如下。

/**
 * 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:
    /*
     * @param root: The root of the BST.
     * @param p: You need find the successor node of p.
     * @return: Successor of p.
     */
    TreeNode * inorderSuccessor(TreeNode * root, TreeNode * p) {
        if (!root) return NULL;
        
        TreeNode * successor = NULL;
        
        while(root) {
            if (p->val >= root->val) {
                root = root->right;
            } else {
                if (!successor || root->val < successor->val) {
                    successor = root;
                }
                root = root->left;
            }
        }
        return successor;
    }
};

另一种写法：
注意：二分查找和Inorder顺序不一样！这里的pre是用作Inorder的Successor!
中序遍历的successor 对应于二分查找中的最后一次大于p的那个root！

class Solution {
public:
    /*
     * @param root: The root of the BST.
     * @param p: You need find the successor node of p.
     * @return: Successor of p.
     */
    TreeNode * inorderSuccessor(TreeNode * root, TreeNode * p) {
        if (!root || !p) return NULL;
        
        TreeNode *succ = NULL; //注意：二分查找和Inorder顺序不一样！这里的pre是用作Inorder的Successor!
        //中序遍历的successor 对应于 二分查找中的最后一次大于p的那个root！
        while(root) {
            if (root->val <= p->val) {
                root = root->right;
            } else {
                //记住！我们要找到最后一次大于p的那个root!
                succ = root;
                root = root->left;
            }
        }
        return succ;
    }
};

解法2：递归的写法。

class Solution {
public:
    /*
     * @param root: The root of the BST.
     * @param p: You need find the successor node of p.
     * @return: Successor of p.
     */
    TreeNode * inorderSuccessor(TreeNode * root, TreeNode * p) {
        if (!root || !p) return succ;
        
        //注意：二分查找和Inorder顺序不一样！这里的pre是用作Inorder的Successor!
        //中序遍历的successor 对应于 二分查找中的最后一次大于p的那个root！
        if (root->val <= p->val) {
            return inorderSuccessor(root->right, p);
        }
        succ = root;
        return inorderSuccessor(root->left, p);
    }
private:
    TreeNode *succ = NULL;
};

解法3：利用通用的Binary Tree中序遍历。没有用到BST这个性质。

/**
 * 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:
    /*
     * @param root: The root of the BST.
     * @param p: You need find the successor node of p.
     * @return: Successor of p.
     */
    TreeNode * inorderSuccessor(TreeNode * root, TreeNode * p) {
        helper(root, p);
        return successor;
    }
private:
    void helper(TreeNode *root, TreeNode *p) {
        if (!root) return;
        helper(root->left, p);

        if (find) {
            successor = root;
            find = false;
            return;
        } else {
            if (root == p) find = true;
        }

        helper(root->right, p);
        
    }
    bool find = false;
    TreeNode * successor = NULL;
};

二刷：也是通用的binary tree中序遍历，没用到BST有序这个性质。


class Solution {
public:
    /*
     * @param root: The root of the BST.
     * @param p: You need find the successor node of p.
     * @return: Successor of p.
     */
    TreeNode * inorderSuccessor(TreeNode * root, TreeNode * p) {
        helper(root, p);
        return succ;
    }
private:
    TreeNode *prev = NULL;
    TreeNode *succ = NULL;
    void helper(TreeNode *root, TreeNode *p) {
        if (!root || succ) return;
        helper(root->left, p);
        if (prev && prev->val == p->val) {
            if (!succ) succ = root;
            return;
        } else {
            prev = root;
        }
        helper(root->right, p);
    }
};