[leetcode] 99. Recover Binary Search Tree

Description

Two elements of a binary search tree (BST) are swapped by mistake.

Recover the tree without changing its structure.

Example 1:

Input:

 [1,3,null,null,2]

   1
  /
 3
  \
   2

Output:

[3,1,null,null,2]

   3
  /
 1
  \
   2

Example 2:

Input:

[3,1,4,null,null,2]

  3
 / \
1   4
   /
  2

Output:

[2,1,4,null,null,3]

  2
 / \
1   4
   /
  3

Follow up:

• A solution using O(n) space is pretty straight forward.
• Could you devise a constant space solution?

分析

题目的意思是：二叉搜索树的两个值被错误的交换了，现在要求在不改变结构的情况下，恢复这棵二叉搜索树。

这是O(1)的方式，hard难度，这里用到了Morris 遍历.

Morris Traversal方法可以做到这两点，只需要O(1)空间，而且可以在O(n)时间内完成。

要使用O(1)空间进行遍历，最大的难点在于，遍历到子节点的时候怎样重新返回到父节点（假设节点中没有指向父节点的p指针），由于不能用栈作为辅助空间。为了解决这个问题，Morris方法用到了线索二叉树（threaded binary tree）的概念。在Morris方法中不需要为每个节点额外分配指针指向其前驱（predecessor）和后继节点（successor），只需要利用叶子节点中的左右空指针指向某种顺序遍历下的前驱节点或后继节点就可以了。

中序遍历：

1. 如果当前节点的左孩子为空，则输出当前节点并将其右孩子作为当前节点。

2. 如果当前节点的左孩子不为空，在当前节点的左子树中找到当前节点在中序遍历下的前驱节点。

   a) 如果前驱节点的右孩子为空，将它的右孩子设置为当前节点。当前节点更新为当前节点的左孩子。

   b) 如果前驱节点的右孩子为当前节点，将它的右孩子重新设为空（恢复树的形状）。输出当前节点。当前节点更新为当前节点的右孩子。

3. 重复以上1、2直到当前节点为空。

C++实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void recoverTree(TreeNode* root) {
        TreeNode* first=NULL,*second=NULL,*parent=NULL;
        TreeNode* cur=root;
        TreeNode* pre=NULL;
        while(cur){
            if(!cur->left){
                if(parent&&parent->val>cur->val){ //record
                    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){  //record
                        if(!first) first=parent;
                        second=cur;
                    }
                    parent=cur;
                    cur=cur->right;
                }
            }
        }
        if(first&&second) swap(first->val,second->val);
    }
};

Python实现

C++的解法有点复杂，这里用中序遍历，第一个升序顺序错乱最大值节点，和最后一个升序顺序错乱的最小值节点。然后交换两个节点val即可。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    prev = TreeNode(-2**31)
    first_max = None
    last_min = None

    def inorder(self, root):
        if root is None:
            return 
        self.inorder(root.left)
        if root.val<self.prev.val:
            self.last_min = root
            if self.first_max is None:
                self.first_max = self.prev
        
        self.prev = root
        self.inorder(root.right)


    def recoverTree(self, root: Optional[TreeNode]) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        self.inorder(root)
        if self.first_max and self.last_min:
            self.first_max.val, self.last_min.val = self.last_min.val, self.first_max.val

参考文献

[编程题]recover-binary-search-tree
Morris Traversal方法遍历二叉树（非递归，不用栈，O(1)空间）