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