Leetcode-Recover BST

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?

O(n) time and O(1) space solution: Morris Traversal

 /**
  * 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) {
         if (root==null) return;

         TreeNode pre=null,cur=null,first=null,second=null;
         cur = root;
         while (cur!=null){
             //cur.left is null.
             if (cur.left==null){
                 if (pre!=null && pre.val>cur.val){
                     if (first==null){
                         first = pre;
                         second = cur;
                     } else second = cur;
                 }
                 pre = cur;
                 cur = cur.right;
             } else {
                 //get predecessor.
                 TreeNode temp = getPredecessor(cur);
                 if (temp.right==null){
                     temp.right=cur;
                     cur = cur.left;
                 } else {
                     if (pre!=null && pre.val>cur.val){
                         if (first==null){
                             first = pre;
                             second = cur;
                         } else second = cur;
                     }
                     temp.right = null;
                     pre = cur;
                     cur = cur.right;
                 }
             }
         }

         if (first==null) return;

         int temp = first.val;
         first.val = second.val;
         second.val = temp;

         return;
     }

     public TreeNode getPredecessor(TreeNode cur){
         TreeNode pre = cur.left;
         while (pre.right!=null && pre.right!=cur){
             pre = pre.right;
         }

         return pre;
     }
 }

O(log(n)) space solution:

 /**
  * Definition for binary tree
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
  *     TreeNode(int x) { val = x; }
  * }
  */
 class Result {
     TreeNode pre;
     TreeNode first;
     TreeNode second;
     Result() {
         pre = first = second = null;
     }
 }

 public class Solution {
     public void recoverTree(TreeNode root) {
         Result res = new Result();
         recoverTreeRecur(root,res);
         if (res.first!=null && res.second!=null){
             int temp = res.first.val;
             res.first.val = res.second.val;
             res.second.val = temp;
         }
     }

     public void recoverTreeRecur(TreeNode cur, Result res){
         if (cur==null)
             return;

         recoverTreeRecur(cur.left, res);
         if (res.pre==null) res.pre = cur;
         else if (res.pre.val>cur.val){
             if (res.first==null)
                 res.first = res.pre;
             res.second = cur;
         }

         res.pre = cur;
         recoverTreeRecur(cur.right,res);
     }
 }