leetcode 99. recover binary search tree 算法题解

题目给出了一个二叉搜索树，这个二叉搜索树中有两个节点被错误地交换了，题目的要求是恢复这棵二叉搜索树。

我第一时间冒出的想法就是暴力搜索，枚举所有节点，然后检查二叉搜索树是否符合要求，复杂度为$O(n^2)$。这个显然太暴力了，不是没有办法不会用这个方法。

第二个想法就是分类讨论，两个节点交换可能会有零个/一个/两个节点与其左右节点不相容。这里我有点忘记二叉搜索树的定义，二叉搜索树要求根节点比左子树所有节点大，比右子树所有节点小，因此只是检查左右孩子显然不能达到要求。

第三个想法是在做第二个想法的时候发现的。我画了很多图，发现恢复的时候并没有改变二叉树的结构，恢复的过程也只是涉及到TreeNode->val的交换。进一步思考，发现二叉搜索树本质上时一组数轴上数据的有序组织，因此恢复的过程实际上就是这组数轴上数据重新恢复有序的过程。
因此很容易有这样的想法：将二叉搜索树上所有的点压入到一个数组中进行排序，然后将其重新赋值给每一个节点。那么怎么样去确定二叉搜索树中哪个节点对应哪个数据呢？还是从其定义入手。二叉搜索树中左孩子的数量意味着在当前子树中有多少个节点比该节点小，那么如果根节点可以提供其左孩子数量和自身，就可以唯一的在数组中确定这个节点。

因此有下面伪代码：
使用后序遍历，对于每一个节点，更新它们的左子树节点数量和右子树节点数量，并将其自身val压入数组中
对于数组进行排序
提供前置数据和该节点，重新对该节点进行赋值，并递归地更新其左右节点。

代码：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <map>
using namespace std;


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

void printTree(TreeNode* root)
{
    queue<TreeNode*> q;
    q.push(root);
    while(!q.empty())
    {
        TreeNode* point = q.front(); q.pop();
        if(point!=NULL)
        {
            cout<<point->val<<",";
            q.push(point->left);
            q.push(point->right);
        }
        else
            cout<<"null,";
    }
}

class Solution {
private:
    map<int,int> leftNum;
    map<int,int> rightNum;
    vector<int> valueSet;
public:
/*
思路一：
因为原来的树有且只有两个点是有问题的，所以有两种情况：
1.有两个点与二叉搜索树的规则不相符合，这时候交换这两个点肯定能够恢复这棵二叉搜索树
2.只有一个点与二叉搜索树的规则不相符合。这时候通过不断移动这个节点（比左子树小与左边交换，比右子树大往右交换）来恢复这棵树

遍历的同时存放节点与其父亲指针的对应关系（可以认为每个节点的value是唯一的，这时候通过map可以实现搜索）
但是这个思路是有问题的，因为可能存在没有点违反其与左右孩子的关系，但是二叉树依旧矛盾的情况（右孩子的最小值小于根节点）

思路二：
观察例题给出的两棵树可以发现，树的结构并没有发生变化，变化的只是数字。
    如果把每个数字投射到数轴上会发现，树的恢复的本质其实就是点的序列恢复升序的过程。
    因此，如果将所有的数字投射到数轴上进行重新排序后再全部改回去，就可以了。

    使用前序遍历保存一个点的左孩子的数量和右孩子的数量，根据二叉搜索树的定义，左孩子数量代表数轴上比它小的数（需要根节点提供足够的信息），依此可以确定其在数轴上的位置
        因为后面的修改会扰乱顺序，因此左孩子数量确定的时候
*/
    void recoverTree(TreeNode* root) {
        //后序排列，确定左孩子的数量和右孩子的数量，并将所有的数据压入到valueSet中
        postorder(root);
        //valueSet进行排序
        sort(valueSet.begin(),valueSet.end());
        //重新开始前序遍历，提供前缀加数（即根节点左孩子的数目加上根节点本身）和搜寻节点，重新设定
        recover(root,0);
    }

    int postorder(TreeNode* root)
    {
        valueSet.push_back(root->val);
        if(root->left == NULL)
        {
            leftNum[root->val] = 0;
        }
        else
        {
            leftNum[root->val] = postorder(root->left);
        }

        if(root->right == NULL)
        {
            rightNum[root->val] = 0;
        }
        else
        {
            rightNum[root->val] = postorder(root->right);
        }

        return leftNum[root->val] + rightNum[root->val] + 1;
    }

    void recover(TreeNode* root,int previousNum)
    {
        int index = previousNum + leftNum[root->val];

        if(root->left!=NULL)
        {
            recover(root->left,previousNum);
        }
        if(root->right!=NULL)
        {
            recover(root->right,previousNum+leftNum[root->val]+1);
        }

        root->val = valueSet[index];
    }

};

int main(void)
{
    Solution s;
    TreeNode* one = new TreeNode(1);
    TreeNode* two = new TreeNode(2);
    TreeNode* three = new TreeNode(3);
    TreeNode* four = new TreeNode(4);

    three->left = one;
    three->right = four;
    four->left = two;

    s.recoverTree(three);
    printTree(three);

    return 0;
}