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.

题目说一个二叉搜索树的两个节点被错误交换，要求不改变树的结构恢复正常的二叉搜索树。

解法一：

O(n)的空间复杂度的解决办法是比较容易的，我们可以把二叉搜索树按中序遍历赋值到数组中，然后直接扫描数组元素记录相邻两个数字逆序的位置，相邻两个数字逆序的对数可能有一对，也可能有两对。假设元素按顺序排序是1、2、3、4、5.一对的情况，如：1、2、4、3、5，这样我们直接交换4和3的值即可。如果是两对的情况，例如1、5、3、4、2，我们查找到逆序位置的元素5和2，交换5和2即可。

但是如何根据这个信息去交换二叉树中的节点呢？我们可以存储元素值与树节点指针的映射，用STL的map容器，key为元素值，value为节点指针。

代码如下：

/**
 * 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<int> v;
        map<int, TreeNode*> mm;
        //inorder 
        stack<TreeNode*> s;
        s.push(root);
        while (!s.empty()) {
            TreeNode *tmp = s.top();
            while (tmp->left!=NULL) {
                s.push(tmp->left);
                tmp = tmp->left;
            }
            v.push_back(tmp->val);
            mm[tmp->val] = tmp;
            s.pop();
            while (tmp->right==NULL && !s.empty()) {
                tmp = s.top();
                v.push_back(tmp->val);
                mm[tmp->val] = tmp;
                s.pop();
            }
            if (tmp->right!=NULL)
                s.push(tmp->right);
        }
        int p1=-1, p2 = -1;
        for (int i=1; i<v.size(); ++i) {
            if (v[i]<v[i-1]) {
                if (p1==-1) {
                    p1 = i-1;
                } else {
                    p2 = i-1;
                }
            }
        }

        if (p2==-1) {
            swap(mm[v[p1]]->val, mm[v[p1+1]]->val);
        } else {
            swap(mm[v[p1]]->val, mm[v[p2+1]]->val);
        }
    }
private:
    void swap(int &a, int &b) {
        int tmp = a;
        a = b;
        b = tmp;
    }
};

解法二：

认真考虑二叉搜索树的性质，左子树的值比根节点小，右子树的值比根节点大，如果两个节点值被交换，有下面四种情况，一是左右子树的两个节点被交换，二是根节点与左子树一节点被交换，三是根节点与右子树一节点被交换，四是左子树或者右子树里面的两个节点被交换。

情况一时，我们可以在左子树中找比根节点值大的节点值，在右子树中找比根节点值小的节点值，然后交换找到的两个节点的值；

情况二时，我们要找到左子树中比根节点值最大的节点，然后交换根节点与找到的节点；

情况三时，我们要找到右子树中比根节点值最小的节点，然后交换根节点与找到的节点；

情况四时，我们对根节点的左右子树再递归调用这样的操作。

那么如何判断是哪种情况发生了呢？通过在左子树中找比根节点大的最大节点x，在右子树中找比根节点值小的最小节点y，如果x和y都存在，说明是x和y被交换了；如果x存在而y不存在，只能是根节点与x被交换了；类似，如果y存在而x不存在，只能是根节点与y被交换了；如果都不存在，那么是左子树或右子树里的两个节点被交换了。

/**
 * 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) {
        if (root==NULL)
            return;
        //找左子树孩子的最大值节点
        TreeNode *leftBiggest = root;
        find(root->left, leftBiggest, "largest"); 
        //找右子树孩子的最小值节点
        TreeNode *rightSmallest = root;
        find(root->right, rightSmallest, "smallest");
        
        // root的两个左右子孙误交换了
        if (leftBiggest!=root && rightSmallest!=root) {
            swap(leftBiggest->val, rightSmallest->val);
        } else if(leftBiggest != root) {  //右子树正常，root与leftBiggest误交换了
            swap(root->val, leftBiggest->val);
        } else if (rightSmallest != root) {  //左子树正常，root与rightSmallest误交换了
            swap(root->val, rightSmallest->val);
        } else {   // 左子树或右子树里的两个节点误交换
            recoverTree(root->left);
            recoverTree(root->right);
        }
    }
private:
    void find(TreeNode *root, TreeNode *&p, const string& relation) {
        if (root == NULL)
            return;
        if (relation=="smallest" && root->val<p->val)
            p = root;
        else if (relation=="largest" && root->val>p->val)
            p = root;
        find(root->left, p, relation);
        find(root->right, p, relation);
    }
    void swap(int &a, int &b) {
        int tmp = a;
        a = b;
        b = tmp;
    }
};