LeetCode Recover Binary Search Tree

题目

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

Recover the tree without changing its structure.

根据上一题的合法性判断，稍作修改，

记录限制元素的位置，可以寻找到不合法的位置，和与之冲突的位置。

根据交换的元素所处的位置，可以分为三种情况：

1、交换的两个位置在一个子树的左右分支上，任何一个元素都不在以另一个元素为根的子树上；

此时交换的这两个位置必然不合法，且是所在分支中不合法位置中深度最小的；

可以首先找到一个不合法的元素。去除以该位置为根的子树后，可找到第二个不合法的元素，交换两者即可。

2、交换的两个位置在一个子树上，一个为该子树的根，另一个在该子树的左子树上；

此时左子树上存在不合法位置，其与发生交换的子树的根冲突；

寻找到第一个不合法位置后，即可找到冲突的位置，即为其中一个交换位置；

另一个元素是第一个交换位置左子树中的最大元素，找到后交换即可；

3、交换的两个位置在一个子树上，一个为该子树的根，另一个在该子树的右子树上；

此时左子树合法，右子树上存在不合法位置，其与发生交换的子树的根冲突；

寻找到第一个不合法位置后，即可找到冲突的位置，即为其中一个交换位置；

另一个元素是第一个交换位置右子树中的最小元素，找到后交换即可；

代码：

/**
* Definition for binary tree
* struct TreeNode {
*     int val;
*     TreeNode *left;
*     TreeNode *right;
*     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
struct dp	//探测用点
{
TreeNode *tn,*min,*max;	//当前位置，当前位置的下限所在位置，上限所在位置
dp(TreeNode *t=NULL,TreeNode *mi=NULL,TreeNode *ma=NULL):tn(t),min(mi),max(ma){}
};
dp test(vector<dp> &sdp)	//dfs寻找不符合条件的点
{
int min,max;
dp dp1;
while(!sdp.empty())	//dfs
{
dp1=sdp.back();
sdp.pop_back();
min=dp1.min==NULL?INT_MIN:dp1.min->val;	//求限制的值
max=dp1.max==NULL?INT_MAX:dp1.max->val;
if(dp1.tn==NULL)
continue;
if(dp1.tn->val<=min||dp1.tn->val>=max)	//不符合要求则返回相应信息
{
return dp1;
break;
}
sdp.push_back(dp(dp1.tn->right,dp1.tn->val>min?dp1.tn:dp1.min,dp1.max));	//更新限制
sdp.push_back(dp(dp1.tn->left,dp1.min,dp1.tn->val<max?dp1.tn:dp1.max));
}
return dp();
}
TreeNode* find_min(TreeNode *root,TreeNode *min)	//寻找分支中最小值的点
{
if(root!=NULL)
{
if(root->val<min->val)
min=root;
min=find_min(root->left,min);
min=find_min(root->right,min);
}
return min;
}
TreeNode* find_max(TreeNode *root,TreeNode *max)	//寻找分支中最大值的点
{
if(root!=NULL)
{
if(root->val>max->val)
max=root;
max=find_max(root->left,max);
max=find_max(root->right,max);
}
return max;
}
void recoverTree(TreeNode *root) {
dp first,second;	//记录不符合要求的点的位置
TreeNode *tp;
vector<dp> sdp;	//dfs用栈
sdp.push_back(dp(root));	//压入根
first=test(sdp);	//探测第一个
if(first.tn==NULL)
return;
second=test(sdp);	//探测非第一个外的分支，找第二个
if(second.tn!=NULL)	//存在，说明交换的位置在一个子树树的左右子树上，交换回来即可
{
cout<<"c1";
swap(first.tn->val,second.tn->val);
return;
}
sdp.clear();	//否则，说明交换的位置在一个子树上，其中一个交换位置是该子树的根
int min=first.min==NULL?INT_MIN:first.min->val;
int max=first.max==NULL?INT_MAX:first.max->val;
if(first.tn->val<min)	//超下界，说明另一个交换的位置在分支的左子树上，寻找分支最小的位置，和冲突位置交换
{
tp=find_min(first.tn,first.tn);
swap(first.min->val,tp->val);
return;
}
if(first.tn->val>max)	//超上界，说明另一个交换的位置在分支的右子树上，寻找分支最大的位置，和冲突位置交换
{
tp=find_max(first.tn,first.tn);
swap(first.max->val,tp->val);
return;
}
}
};