1、题目描述
二叉搜索树中的两个节点被错误地交换。
请在不改变其结构的情况下,恢复这棵树。
进阶:
使用 O(n) 空间复杂度的解法很容易实现。
你能想出一个只使用常数空间的解决方案吗?
2、示例
输入: [3,1,4,null,null,2]
3
/ \
1 4
/
2
输出: [2,1,4,null,null,3]
2
/ \
1 4
/
3
3、题解
简化版:中序遍历+逆序对+递归
基本思想:先基于栈的中序遍历二叉树,得到中序遍历序列middleOrder,然后基于双指针在middleOrder序列中找逆序对swap1和swap2,最后基于递归遍历二叉树找到swap1和swap2两个节点值并交换。
#include<iostream>
#include<vector>
#include<algorithm>
#include<stack>
using namespace std;
#define inf 9999
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode() : val(0), left(nullptr), right(nullptr) {}
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {}
};
void Init_TreeNode(TreeNode** T, vector<int>& vec, int& pos)
{
if (vec[pos] == inf || vec.size() == 0)
{
*T = NULL;
return;
}
else
{
(*T) = new TreeNode(0);
(*T)->val = vec[pos];
Init_TreeNode(&(*T)->left, vec, ++pos);
Init_TreeNode(&(*T)->right, vec, ++pos);
}
}
void PreOrderTraverse(TreeNode* T)
{
if (T == NULL)
return;
cout << T->val << " ";
PreOrderTraverse(T->left);
PreOrderTraverse(T->right);
}
class Solution {
public:
void recoverTree(TreeNode* root) {
//简化版:中序遍历+逆序对+递归
vector<int> nums;
stack<TreeNode*> st;
TreeNode* p=root;
while(!st.empty()||p)
{
while(p)
{
st.push(p);
p=p->left;
}
p=st.top();
nums.push_back(p->val);
st.pop();
p=p->right;
}
int low=0,high=nums.size()-1;
while(low<nums.size())
{
if(nums[low]>nums[low+1])
break;
low++;
}
while(high>=0)
{
if(nums[high]<nums[high-1])
break;
high--;
}
Recursion(root,nums[low],nums[high]);
}
void Recursion(TreeNode* root,int num1,int num2)
{
if(root==nullptr)
return;
if(root->val==num1||root->val==num2)
root->val=root->val==num1?num2:num1;
Recursion(root->left,num1,num2);
Recursion(root->right,num1,num2);
}
};
class Solution1 {
public:
void recoverTree(TreeNode* root) {
//基本思想:先基于栈的中序遍历二叉树,得到中序遍历序列middleOrder
//然后基于双指针在middleOrder序列中找逆序对swap1和swap2
//最后基于递归遍历二叉树找到swap1和swap2两个节点值并交换
if (root == NULL)
return;
vector<int> middleOrder;
stack<TreeNode*> st;
TreeNode* p = root;
int swap1 = -1, swap2 = -1;
//基于栈的中序遍历二叉树,得到中序遍历序列middleOrder
while (p != NULL || !st.empty())
{
while (p != NULL)
{
st.push(p);
p = p->left;
}
p = st.top();
st.pop();
middleOrder.push_back(p->val);
p = p->right;
}
//基于双指针在middleOrder序列中找逆序对swap1和swap2
int i = 0, j = middleOrder.size() - 1;
while (swap1 == -1 || swap2 == -1)
{
if (middleOrder[i] > middleOrder[i + 1])
swap1 = i;
else
i++;
if (middleOrder[j] < middleOrder[j - 1])
swap2 = j;
else
j--;
}
//基于递归遍历二叉树找到swap1和swap2两个节点值并交换
Traverse(root, middleOrder[swap1], middleOrder[swap2]);
}
void Traverse(TreeNode* T, int swap1, int swap2)
{
if (T == NULL)
return;
if (T->val == swap1 || T->val == swap2)
T->val = T->val == swap1 ? swap2 : swap1;
Traverse(T->left, swap1, swap2);
Traverse(T->right, swap1, swap2);
}
};
int main()
{
Solution solute;
TreeNode* root = NULL;
vector<int> vec = { 3,1,inf,inf,4,2,inf,inf,inf };
int pos = 0;
Init_TreeNode(&root, vec, pos);
solute.recoverTree(root);
PreOrderTraverse(root);
return 0;
}