leetcode 99. Recover Binary Search Tree BST二叉搜索树的两元素交换的恢复 + 中序遍历 + 很棒的分析和做法

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?

这道题考察的重点就是二叉搜索树BST的中序遍历是得到的是一个从小到大的序列。

BST的两个数交换了，修复BST。总体思路就是中序遍历，找到BST的两个错误的节点，然后交换数值。值得注意的是，错误的节点有两种情况，比如开始中序遍历为1,2,3,4,5

1、中序遍历相邻，比如1,3,2,4,5。此时中序遍历只会存在一次错误。

2、中序遍历不相邻，比如1,4,3,2,5.此时中序遍历会出现两次错误。

所以在实际处理时，在遇到第一次错误时，记录两个节点；如果之后还有错误，更新节点。

代码如下：

/*class TreeNode
{
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}*/

/*
* 基本知识点：二叉搜索树的中序遍历就是升序序列。因此不满足升序的两个点就是互换的地方。
*
* BST的两个数交换了，修复BST。总体思路就是中序遍历，找到BST的两个错误的节点，然后交换数值。
* 值得注意的是，错误的节点有两种情况，比如开始中序遍历为1,2,3,4,5
*
* 1、中序遍历相邻，比如1,3,2,4,5。此时中序遍历只会存在一次错误。
*
* 2、中序遍历不相邻，比如1,4,3,2,5.此时中序遍历会出现两次错误。
*
* 所以在实际处理时，在遇到第一次错误时，记录两个节点；如果之后还有错误，更新节点。
* */
public class Solution
{
TreeNode mistake1=null, mistake2=null;
TreeNode pre=null;

public void recoverTree(TreeNode root)
{
InOrderTraversal(root);
if(mistake1!=null && mistake2!=null)
{
int tmp=mistake1.val;
mistake1.val=mistake2.val;
mistake2.val=tmp;
}
}

void InOrderTraversal(TreeNode root)
{
if(root==null)
return ;
else
{
InOrderTraversal(root.left);
if(pre!=null && root.val <= pre.val)
{
//当第一次出现的时候
if(mistake1==null)
{
mistake1=pre;
mistake2=root;
}else
mistake2=root;
}
pre=root;
InOrderTraversal(root.right);

}
}
}

下面是C++的做法，这道题很棒，分析了可能出现的两种情况，然后分别处理很棒

代码如下：

#include<iostream>
#include <vector>

using namespace std;

/*
struct TreeNode
{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
*/

class Solution
{
public:
TreeNode* mistake1 = NULL;
TreeNode* mistake2 = NULL;
TreeNode* pre = NULL;
void recoverTree(TreeNode* root)
{
inOrder(root);
if (mistake1 != NULL && mistake2 != NULL)
{
int tmp = mistake1->val;
mistake1->val = mistake2->val;
mistake2->val = tmp;
}
}

void inOrder(TreeNode* root)
{
if (root == NULL)
return;
else
{
inOrder(root->left);
if (pre != NULL && root->val <= pre->val)
{
if (mistake1 == NULL)
{
mistake1 = pre;
mistake2 = root;
}else
mistake2 = root;
}
pre = root;
inOrder(root->right);
}
}
};