[leetcode刷题系列]Recover Binary Search Tree

这题目以前还真没做过， 这种题在acm中基本上没办法考察， 要求常数空间神马的

第一次见到的时候， 没想到好的算法， 放弃了， 然后今天决定剩下不到30道leetcode题目要挨个刷，

再次见到这个题目， 只有硬着头皮上了。想了一会其实就想到了。 可见遇到不会的还是要仔细想下- - 其实不难。

对于这道题，我们可以中序遍历这棵树， 然后每次访问一个节点的时候就把它的值表示到一个变量里。

然后我们访问当前节点的时候， 如果当前节点的值小于这个全局变量的值， 那么这个位置就是异常。

其实在我们讲这个bst转化为数组的情况下，就相当于当前位置小于他前面的那个元素。 而正常情况下

每个位置的值都要大于他前面的位置的值，所以这个肯定是异常的。所以我们就把这个位置和他前面的位置记录下来。

最后遍历完， 有两种情况， 一种是这样的异常位置对数只有一对， 那么很显然， 就是这两个位置的值被交换了。 我们

直接swap这两个位置的值就ok。另外一种情况是这样的异常位置数有两对，  那么其实只要比划一下就明白了。

被交换了的位置是第一个异常位置对数的前一个， 以及第二个异常位置对数的后一个。这样我们交换他们就ok了。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    int p = 0;
    TreeNode * pre, *now;
    TreeNode * a[2][2];
    void dfs(TreeNode * root, int &in){
        if(root->left != 0)
            dfs(root->left, in);
        if(root->val < in){
            a[p][0] = now;
            a[p][1] = root;
            p ++ ;
        }
        pre = now;
        now = root;
        in = root->val;
        if(root->right != 0)
            dfs(root->right, in);
    }
public:
    void recoverTree(TreeNode *root) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if(root == 0)
            return ;
        p = 0;
        pre = now = 0;
        int in = INT_MIN;;
        dfs(root, in);
        
        // two case
        if(p == 1)
            swap(a[0][0]->val, a[0][1]->val);
        if(p == 2)
            swap(a[0][0]->val, a[1][1]->val);
    }
};

=====我是分割线===============

嗯，感谢cy的分享。其实上面代码由于用到了递归，所以要严格意义上讲并不是O(1)的空间复杂度。

从cy那里得知了morris遍历二叉树的方法。

下面是利用morris方法实现的版本。

关于morris可以看这个链接点击打开链接

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    int p = 0, pre_val = INT_MIN;
    TreeNode* exp[2][2];
    TreeNode* pre;
    void visit(TreeNode * cur){
        if(cur->val < pre_val){
            exp[p][0] = pre;
            exp[p][1] = cur;
            ++p;
        }
        pre = cur;
        pre_val = cur->val;
    }
    void morris(TreeNode * root){
        p = 0;
        pre_val = INT_MIN;
        pre = 0;
        TreeNode * cur = root;
        while(cur != 0){
            if(cur->left == 0){
                visit(cur);
                cur = cur->right;
            }else{
                TreeNode * pre_node = cur->left;
                while(pre_node->right != 0 && pre_node->right != cur)
                    pre_node = pre_node->right;
                if(pre_node->right == cur){
                    visit(cur);
                    pre_node->right = 0;
                    cur = cur->right;
                }else{
                    pre_node->right = cur;
                    cur = cur->left;
                }
            }
        }
    }
public:
    void recoverTree(TreeNode *root) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        morris(root);
        if(p == 1)
            swap(exp[0][0]->val, exp[0][1]->val);
        else if(p == 2){
            swap(exp[0][0]->val, exp[1][1]->val);
        }
    }
};