Two elements of a binary search tree (BST) are swapped by mistake.
Recover the tree without changing its structure.
Example 1:
Input: [1,3,null,null,2] 1 / 3 \ 2 Output: [3,1,null,null,2] 3 / 1 \ 2
Example 2:
Input: [3,1,4,null,null,2] 3 / \ 1 4 / 2 Output: [2,1,4,null,null,3] 2 / \ 1 4 / 3
Follow up:
- A solution using O(n) space is pretty straight forward.
- Could you devise a constant space solution?
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public void recoverTree(TreeNode root) {
if (root == null) { return; }
TreeNode pre = null, first = null, second = null;
Stack<TreeNode> stk = new Stack<>();
while (!stk.isEmpty() || root != null) {
while (root != null) {
stk.push(root);
root = root.left;
}
TreeNode cur = stk.pop();
if (pre != null && pre.val >= cur.val) {
if (first == null) {
first = pre;
}
if (first != null) {
second = cur;
}
}
root = cur.right;
pre = cur;
}
int tmp = first.val;
first.val = second.val;
second.val = tmp;
return;
}
}
2
Just use the "first" and "second" pointer to find the 2 nodes that violate the order. Then change the value of the first node ad the second node by their value.
class Solution {
TreeNode* first=NULL;
TreeNode* second=NULL;
TreeNode* prev = new TreeNode(INT_MIN);
public:
void recoverTree(TreeNode* root) {
help(root);
swp(first->val, second->val);
}
void help(TreeNode* root){
if(root==NULL) return;
help(root->left);
if(first==NULL && prev->val >= root->val) first=prev;
if(first!=NULL && prev->val >= root->val) second=root;
prev=root;
help(root->right);
}
}