leetcode 6

二叉搜索树中的两个节点被错误地交换。

请在不改变其结构的情况下，恢复这棵树。

示例 1:

输入: [1,3,null,null,2]

  1
  /
 3
  \
  2

输出: [3,1,null,null,2]

  3
  /
 1
  \
  2

示例 2:

输入: [3,1,4,null,null,2]

3
/ \
1 4
  /
  2

输出: [2,1,4,null,null,3]

2
/ \
1 4
  /
 3

/**
 * Definition for a binary tree node.
 * 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) {}
 * };
 */
class Solution {
public:
    void read_tree(vector<int> &nums,TreeNode* root)
    {
        if(root ==NULL)
        return;
        read_tree(nums,root->left);
        nums.push_back(root->val);
        read_tree(nums,root->right);
    }
    pair<int,int> find_swap(vector<int> &nums)
    {
        int n=nums.size();
        int x=-1,y=-1;
        for(int i=0;i<n-1;i++)
        {
            if(nums[i+1]<nums[i])
            {
                y=nums[i+1];
                if(x==-1)
                {
                    x=nums[i];
                }
                else
                break;
            }
        }
        return {x,y};
    }
    void change(pair<int,int> &s,TreeNode* root,int remain)
    {
       if(root!=nullptr)
       {
           if(root->val==s.first || root->val==s.second)
           {
               root->val = root->val==s.first ? s.second:s.first;
               if(--remain == 0) 
               return;
           }
           change(s,root->left,remain);
           change(s,root->right,remain);
       }
    }
    void recoverTree(TreeNode* root) {
        vector <int> nums;
        read_tree(nums,root);
        pair<int,int> s=find_swap(nums);
        change(s,root,2);
    }
};

注意：二叉搜索树（二叉排序树）的中序遍历是从小到大的。因此只要找出中序遍历中不满足从小到大的两个点，然后进行交换就可以得到相应的结果。