99恢复二叉搜索树

原题链接
二叉搜索树中的两个节点被错误地交换。
请在不改变其结构的情况下，恢复这棵树。

package LeetCode.BinarySearch.RecoverTree;


import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 99 恢复二叉搜索树
 */
public class Solution {

    public static void main(String[] args) {
        TreeNode root1 = new TreeNode(1);
        TreeNode root2 = new TreeNode(2);
        TreeNode root3 = new TreeNode(3);
        TreeNode root4 = new TreeNode(4);

        TreeNode root5 = new TreeNode(5);
        TreeNode root6 = new TreeNode(6);
        TreeNode root7 = new TreeNode(7);

        //测试1
        root3.left=root1;
        root3.right=root4;
        root4.left=root2;

//        //测试2
//        root3.left=root6;
//        root3.right=root2;
//
//        root6.left=root1;
//
//        root2.left=root5;
//        root2.right=root7;
//
//        root5.left=root4;

        recoverTree(root3);

    }

    public static void recoverTree(TreeNode root) {
        List<Integer> list=new ArrayList<Integer>();
        //中序遍历得到list
        midVisit(root,list);
//        System.out.println("恢复前： "+Arrays.toString(list.toArray()));
        //找到位置调换的两个元素
        int errorIndex1 = getErrorIndex(list, false);
        int errorIndex2 = getErrorIndex(list, true);

        int one=list.get(errorIndex1);
        int tow = -1;
        if (errorIndex2!=-1){
            tow = list.get(errorIndex2 + 1);
        }else {
            tow = list.get(errorIndex1 + 1);
        }

        swap(root,one,tow);
        List<Integer> list2=new ArrayList<Integer>();
        midVisit(root,list2);
//        System.out.println("恢复后： "+Arrays.toString(list2.toArray()));
    }

    public static void midVisit(TreeNode root , List<Integer> list){
        if (root!=null){
            midVisit(root.left, list);
            list.add(root.val);
            midVisit(root.right, list);
        }
    }

    /**
     * 得到被交换的结点下标
     * @param list
     * @param isGetOne
     * @return
     */
    public static int getErrorIndex(List<Integer> list,boolean isGetOne){
        for (int i = 0; i < list.size(); i++) {
            if (i<list.size()-1&&list.get(i)>list.get(i+1)){
                if (!isGetOne){
                    return i;
                }else {
                    isGetOne=false;
                }
            }
        }
        return -1;
    }

    /**
     * 交换值等于val1和val2的结点
     * @param root
     * @param val1
     * @param val2
     */
    public static void swap(TreeNode root,int val1,int val2){
        if (root!=null){
            if (root.val==val1||root.val==val2){
                root.val=(root.val==val1)?val2:val1;
            }

            swap(root.left, val1, val2);
            swap(root.right, val1, val2);
        }
    }

}

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode() {}

    TreeNode(int val) {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}