[Leetcode] Recover binary search tree 恢复二叉搜索树

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?

confused what"{1,#,2,3}"means? > read more on how binary tree is serialized on OJ.

OJ's Binary Tree Serialization:

The serialization of a binary tree follows a level order traversal, where '#' signifies a path terminator where no node exists below.

Here's an example:

   1
  / 
 2   3
    /
   4
    
     5

The above binary tree is serialized as"{1,2,3,#,#,4,#,#,5}".

 

最简单的办法应该是，中序遍历二叉树，将各个结点的值存储在一维向量中，然后进行一次赋值操作。这种方法对任意个数的节点错乱都实用。

 详情见Grangyang的博客

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void recoverTree(TreeNode *root) 
    {
        vector<TreeNode *> treeNode;
        vector<int> nodeVal;
        inoder(root,treeNode,nodeVal);
        sort(nodeVal.begin(),nodeVal.end());
        for(int i=0;i<treeNode.size();++i)
            treeNode[i]->val=nodeVal[i];
    }

    void inoder(TreeNode *root,vector<TreeNode *> &treeNode,vector<int> &nodeVal)
    {
        if(root==NULL)  return;
        inoder(root->left,treeNode,nodeVal);
        treeNode.push_back(root);
        nodeVal.push_back(root->val);
        inoder(root->right,treeNode,nodeVal);
    }
};

 方法二：

用三个指针，w1,w2分别指向第一、二个错误的地方。pre指向当前结点中序遍历中的前一个结点。因有两个结点交换了，所以二叉树的中序遍历中会出现违背有序的情况，一、即中序遍历中相邻的结点被交换，则违背有序的情况出现一次，如132456；二、中序遍历中不相邻的两个结点的值被交换，则出现两次违背有序情况，如153426.针对情况1，pre=3，w1=pre即为3，w2=root，即为2，在后续的遍历中没有违背有序的情况，所以交换w1和w2即可；针对情况2，找到第一个错误点后，w1 ！=NULL了，所以，第二个错误点w2=root，第一逆序的前结点，第二逆序的后结点，交换两者即可。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode *w1,*w2,*pre;
    void recoverTree(TreeNode *root) 
    {
        if(root==NULL)  return;
        w1=w2=pre=NULL;
        find(root);
        swap(w1->val,w2->val);
    }
    void find(TreeNode *root)
    {
        if(root==NULL)  return;
        find(root->left);
        if(pre&&pre->val > root->val)
        {
            if(w1==NULL)    //情况1
            {
                w1=pre;
                w2=root;
            }
            else            //情况2
                w2=root;
        }
        pre=root;
        find(root->right);
    }
};

方法三

层次遍历中的Mirror方法，修改部分得到。真正的O(1)。

// Now O(1) space complexity
class Solution {
public:
    void recoverTree(TreeNode *root) {
        TreeNode *first = NULL, *second = NULL, *parent = NULL;
        TreeNode *cur, *pre;
        cur = root;
        while (cur) {
            if (!cur->left) {
                if (parent && parent->val > cur->val) {
                    if (!first) first = parent;
                    second = cur;
                }
                parent = cur;
                cur = cur->right;
            } else {
                pre = cur->left;
                while (pre->right && pre->right != cur) pre = pre->right;
                if (!pre->right) {
                    pre->right = cur;
                    cur = cur->left;
                } else {
                    pre->right = NULL;
                    if (parent->val > cur->val) {
                        if (!first) first = parent;
                        second = cur;
                    }
                    parent = cur;
                    cur = cur->right;
                }
            }
        }
        if (first && second) swap(first->val, second->val);
    }
};