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. 

BST:二叉查找树。根节点大于左子树所有节点，根节点小于右子树所有节点。递归定义

题意

一棵BST中有两个节点交换了，恢复这颗树

思路

1.O(N)空间复杂度

中序遍历将节点放到list中，遍历list放到int[]数组中，对int[]数组进行排序，遍历list。list.get(i).val = nums[i]

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Solution {
    List<TreeNode> listOfInOrder = new ArrayList<TreeNode>();
    
    public void recoverTree(TreeNode root) {
        inOrderTravel(root);
        int nums[] = new int[listOfInOrder.size()];
        for(int i = 0; i < nums.length; i++){
            nums[i] = listOfInOrder.get(i).val;
        }//for
        
        Arrays.sort(nums);                             //对数组升序排列
        for(int i = 0; i < nums.length; i++)
            listOfInOrder.get(i).val = nums[i];
    }
    
    /**
     * 中序遍历，节点放到list中
     * @param root
     */
    private void inOrderTravel(TreeNode root){
        if(root != null){
            inOrderTravel(root.left);
            listOfInOrder.add(root);
            inOrderTravel(root.right);
        }
    }
}

 2.O(1)空间复杂度，中序遍历递归

public class Solution
{
    private TreeNode node1 = null;
    private TreeNode node2 = null;
    private TreeNode pre = null;

    public void recoverTree(TreeNode root) {
        if(root == null)
            return;
        inOrderTravel(root);
        
        int temp = node1.val;
        node1.val = node2.val;
        node2.val = temp;
    }

    private void inOrderTravel(TreeNode root){
        if(root != null){
            inOrderTravel(root.left);
            if(pre != null && pre.val > root.val){
                if(node1 == null){
                    node1 = pre;
                    node2 = root;
                }
                    
                node2 = root;
            }//if
            pre = root;
            inOrderTravel(root.right);
        }
    }//inOrderTravel

    public static void main(String args[]){
        TreeNode root = new TreeNode(1);
        TreeNode node1 = new TreeNode(2);
        TreeNode node2 = new TreeNode(3);

        root.right = node1;
        node1.left = node2;

        Solution sol = new Solution();

        inOrderTravelOut(root);
        System.out.println();
        sol.recoverTree(root);
        inOrderTravelOut(root);
    }

    private static void inOrderTravelOut(TreeNode root){
        if(root != null){
            inOrderTravelOut(root.left);
            System.out.print(root.val + " ");
            inOrderTravelOut(root.right);
        }
    }
}