Leetcode OJ: Recover Binary Search Tree

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?

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}".

大意就是恢复有两个位置交换了的二叉排序树。

思路大概就是用中序遍历，然后把顺序不对的两个数找出来。这里有两个问题。

1. 怎么找出两个被错误交换了的节点？

2. 题目要求最好用常量空间复杂度完成，但常见的中序遍历都是需要栈实现的，怎么做到？ 

问题1，只需要判断上一次访问的节点与当前节点的大小关系即可，第一个出现错误的是上一次访问节点（保证第一个出现的只记录一次），第二个出现错误的是当前节点。

问题2，就有点复杂了，我们先展示下用非递归和栈实现的代码：

/**
 * 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 (NULL == root)
            return;
        stack<TreeNode*> nodes;
        TreeNode *p = root;
        TreeNode *pre = NULL, *first = NULL, *second = NULL;
        while (p || !nodes.empty()) {
            while (p) {
                nodes.push(p);
                p = p->left;
            }
            if (!nodes.empty()) {
                p = nodes.top();
                nodes.pop();
                if (pre && pre->val > p->val) {
                    // second有可能是p
                    second = p;
                    if (!first) // first一定是pre
                        first = pre;
                    else // 当first非空，表明second一定是p
                        break;
                }
                pre = p;
                p = p->right;
            }
        }
        // 当所有节点遍历了，second就确定了
        swap(first->val, second->val);
    }
};

这里的判断条件需要认真考虑，pre->val > p->val的情况有可能出现1次（相邻时）或者2次，而first只取第一次出现这种情况时的pre，而second只取最后一次出现这种情况的p。

这是常规的中序遍历+判断条件完成了，可是怎么做到常量空间复杂度？

说实话，LZ没想出来，参考http://www.cnblogs.com/TenosDoIt/p/3445682.html才知道方法。

也是中序遍历，借助线索二叉树的思想，利用空叶子节点作为索引，这里只需要用空右叶子节点。算法为：

1. 当前节点的左子节点为空时，判断是否出现pre->val > p->val的情况，判断完了pre = p，p = p->right

2. 当前节点的左子节点不为空时，找到左子树的最右端非空节点：

　　a) 当此节点不是当前节点（未被访问）时，则令此节点的右子节点指向当前节点

　　b) 否则把此节点的对应父节点的右子节点置空（还原），判断当前节点是否出现pre->val > p->val的情况，判断完了pre = p, p = p->right

代码如下：

/**
 * 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 (NULL == root)
            return;
        TreeNode *p = root;
        TreeNode *pre = NULL, *first = NULL, *second = NULL;
        while (p) {
            if (p->left) {
                TreeNode* tmp = p->left;
                // 找出最右端右子节点不为空且不等于p的
                while (tmp->right != NULL && tmp->right != p) 
                    tmp = tmp->right;
                if (tmp->right != p) { // 右子节点为空
                    tmp->right = p;
                    p = p->left;
                } else {  // 右子节点等于p
                    if (pre->val > p->val) {
                        if (!first)
                            first = pre;
                        second = p;
                    }
                    // 还原
                    tmp->right = NULL;
                    pre = p;
                    p = p->right;
                }
            } else {
                if (pre && pre->val > p->val) {
                    if (!first)
                        first = pre;
                    second = p;
                }
                pre = p;
                p = p->right;
            }
        }
        swap(first->val, second->val);
    }
};

对于这一方法，还原很重要，因为改变了原来的结构，因此也不能像之前说的方法那样可以提前break。