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?

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

Solution 

1.use inorder traversal to solve this problem. 

2.There are two conditions. If the consecutive two nodes are swapped by mistake, there will be only one pair of reversing order numbers in the inorder traversal result. If the two nodes are not consecutive, there will be two pairs of reversing order numbers.

For example, 12345 -> 15342. 5,3 and 4,2 are the two pairs of numbers in reversing order. We need to swap 5 and 2. One is the first number in the first pair and the other is the second number in the second pair.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public void recoverTree(TreeNode root) {
        List<TreeNode> temp = new ArrayList<TreeNode>();
        List<TreeNode> ret = new ArrayList<TreeNode>();
        temp.add(null);
        helper(root, temp, ret);
        
        if (ret.size() > 0) {
            int value = ret.get(0).val;
            ret.get(0).val = ret.get(1).val;
            ret.get(1).val = value;
            
        }
        
    }
    
    
    private void helper(TreeNode root, List<TreeNode> temp, List<TreeNode> ret) {
        if (root == null) {
            return;
        }
        
        helper(root.left, temp, ret);
        if (temp.get(0) != null && root.val < temp.get(0).val) {
             if (ret.size() == 0) {
                ret.add(temp.get(0));
                ret.add(root);
            } else {
                ret.set(1, root);
            }
        }
        
        temp.set(0, root);
        helper(root.right, temp, ret);
    }
}