Recover Binary Search Tree

解法1：消耗O(n)额外空间的方法

/**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector<int> value;
void visit(TreeNode* root)
{
if(root==NULL)
{
return;
}
visit(root->left);
value.push_back(root->val);
visit(root->right);
}
void construct(TreeNode* root,int& pos)
{
if(root==NULL)
{
return;
}
construct(root->left,pos);
root->val=value[pos++];
construct(root->right,pos);
}
void recoverTree(TreeNode *root) {
visit(root);
sort(value.begin(),value.end());
int index=0;
construct(root,index);
}
};

解法2：消耗constant额外空间。关键要理清题意，BST中只有一对元素交换了，所以当发生不合适的情况时，只要把这对不合适的情况置换成合适的情况即可，不再需要递归，否则需要继续递归找不合适的情况。
/**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* maxVal(TreeNode* root)
{
TreeNode* max=root;
if(root->left!=NULL)
{
TreeNode* lm=maxVal(root->left);
if(lm->val>max->val)
{
max=lm;
}
}
if(root->right!=NULL)
{
TreeNode* rm=maxVal(root->right);
if(rm->val>max->val)
{
max=rm;
}
}
return max;
}
TreeNode* minVal(TreeNode* root)
{
TreeNode* min=root;
if(root->left!=NULL)
{
TreeNode* lm=minVal(root->left);
if(lm->val<min->val)
{
min=lm;
}
}
if(root->right!=NULL)
{
TreeNode* rm=minVal(root->right);
if(rm->val<min->val)
{
min=rm;
}
}
return min;
}
void recoverTree(TreeNode *root) {
if(root==NULL)
{
return;
}
TreeNode* lm=NULL;
TreeNode* rm=NULL;
if(root->left!=NULL)
{
lm=maxVal(root->left);
}
if(root->right!=NULL)
{
rm=minVal(root->right);
}
if((lm==NULL)&&(rm==NULL))
{
return;
}
else
{
if(lm==NULL)
{
if(rm->val<root->val)
{
int tmp=rm->val;
rm->val=root->val;
root->val=tmp;
}
else
{
recoverTree(root->right);
}
}
else if(rm==NULL)
{
if(lm->val>root->val)
{
int tmp=lm->val;
lm->val=root->val;
root->val=tmp;
}
else
{
recoverTree(root->left);
}
}
else
{
if(rm->val<lm->val)
{
int tmp=rm->val;
rm->val=lm->val;
lm->val=tmp;
}

else if(rm->val<root->val)
{
int tmp=rm->val;
rm->val=root->val;
root->val=tmp;
recoverTree(root->right);
}
else if(lm->val>root->val)
{
int tmp=lm->val;
lm->val=root->val;
root->val=tmp;
recoverTree(root->left);
}
else
{
recoverTree(root->left);
recoverTree(root->right);
}
}
}
}
};