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);
        }
    }
};