leetcode -- 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?

1.O(n) space solution

中序遍历该BST，得到所有整数对齐排好序，对节点重新进行赋值

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public void recoverTree(TreeNode root) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if(root == null){
            return ;
        }
        ArrayList<TreeNode> nodes = new ArrayList<TreeNode>();
        ArrayList<Integer> values = new ArrayList<Integer>();
        inOrderTraverse(root, nodes, values);
        Collections.sort(values);
        for(int i = 0; i < nodes.size(); i++){
            nodes.get(i).val = values.get(i);
        }
    }
    
    public void inOrderTraverse(TreeNode node, ArrayList<TreeNode> nodes, ArrayList<Integer> values){
        if(node == null){
            return;
        }
        if(node.left != null){
            inOrderTraverse(node.left, nodes, values);
        }
        nodes.add(node);
        values.add(node.val);
        if(node.right != null){
            inOrderTraverse(node.right, nodes, values);
        }
    }
}

 2.using two pointer, worst case O(n) space cost, average O(logN)

have some strange problem, pre is alway null!

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public void recoverTree(TreeNode root) {
        // Start typing your Java solution below
        // DO NOT write main() function
        if(root == null){
            return ;
        }
        TreeNode p1 = null, p2 = null, pre = null;
        find(root, p1, p2, pre);
        swap(p1, p2);
    }
    
    public void find(TreeNode node, TreeNode p1, TreeNode p2, TreeNode pre){
        if(node == null){
            return;
        }
        find(node.left, p1, p2, pre);
        if(pre != null && node.val < pre.val){
            if(p1 == null){
                p1 = pre;
            } else {
                p2 = node;
            }
        }
        pre = node;
        find(node.right, p1, p2, node);
    }
    
    public void swap(TreeNode p1, TreeNode p2){
        if(p1 != null && p2 != null){
            int tmp = p1.val;
            p1.val = p2.val;
            p1.val = tmp;
        }
    }
}

3. using threaded binary tree to do the inorder traverse

http://tech-wonderland.net/blog/leetcode-recover-binary-search-tree.html

http://fisherlei.blogspot.com/2012/12/leetcode-recover-binary-search-tree.html