LeetCode Recover Binary Search Tree

Two elements of a binary search tree (BST) are swapped by mistake.

Recover the tree without changing its structure.

Note:
A solution using O(n) space is pretty straight forward. Could you devise a constant space solution?

confused what

"{1,#,2,3}"

means? > read more on how binary tree is serialized on OJ.

class Solution {
private:
vector<TreeNode*> nodes;
public:
void recoverTree(TreeNode *root) {
nodes.clear();
dfs(root);
// 1 5 3 4 2 6 7
// 1 3 2 4
// 3 2
int len = nodes.size();
if (len < 1) return;

int pre = nodes[0]->val;
int cur = 0;
int first = -1;
int second= -1;
for (int i=1; i<len; i++) {
cur = nodes[i]->val;
if (cur < pre) {
if (first < 0) {
first = i-1;
} else {
second= i;
}
}
pre = cur;
}
if (second < 0) second = first + 1;
int t = nodes[first]->val;
nodes[first]->val = nodes[second]->val;
nodes[second]->val= t;
}

void dfs(TreeNode* root) {
if (root == NULL) return;
dfs(root->left);
nodes.push_back(root);
dfs(root->right);
}
};

先来个"A solution using O(n) space is pretty straight forward"的方法。如果递归调用栈不算额外空间的话，把先序遍历改一下即可，如果算的话...怎么办

来一个伪常数空间的：

/**
* Definition for binary tree
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
private:
vector<TreeNode*> nodes;
TreeNode* pre;
TreeNode* first;
TreeNode* second;
public:
void recoverTree(TreeNode *root) {
nodes.clear();
pre = first = second = NULL;
dfs(root);
// case a. 1 5 3 4 2 6 7
// case b. 1 3 2 4
// case c. 3 2
// case d. 3
// case e. NULL
if (second == NULL) return; // case (d,e)
int t = first->val;
first->val = second->val;
second->val= t;
}

void dfs(TreeNode* root) {
if (root == NULL) return;
dfs(root->left);
visit(root);
dfs(root->right);
}

void visit(TreeNode* node) {
if (pre == NULL) {
pre = node;
return;
}
if (node->val < pre->val) {
if (first == NULL) {
first = pre;
second= node;   // assume swap with node next to pre(case b,c)
} else {
second= node;   // fix above assumption(case a)
}
}
pre = node;
}
};

第二轮：

/**
* 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 {
private:
TreeNode* first;
TreeNode* second;
TreeNode* last;
public:
void recoverTree(TreeNode* root) {
last = first = second = NULL;
dfs(root);
swap(first->val, second->val);
}

void dfs(TreeNode* root) {
if (root == NULL) {
return;
}
dfs(root->left);

if (last != NULL) {
if (last->val > root->val) {
if (first == NULL) {
first = last;
}
second = root;
}
}
last = root;

dfs(root->right);
}
};