static void Main(string[] args)
        {
            /*
             * Test case 1:
             */
            TreeNode n1 = new TreeNode(0);
            n1.left = new TreeNode(1);

            //recoverTree(n1);

            TreeNode n2 = new TreeNode(2);
            n2.right = new TreeNode(1);

            recoverTree(n2);

            TreeNode n3 = new TreeNode(4);
            n3.left = new TreeNode(6);
            n3.left.left = new TreeNode(1);
            n3.left.right = new TreeNode(3);

            n3.right = new TreeNode(2);
            n3.right.left = new TreeNode(5);
            n3.right.right = new TreeNode(7);

            //recoverTree(n3);
        }
        private static TreeNode v2 = null; // the second violation node

        #endregion Fields

        #region Methods

        public static void recoverTree(TreeNode root)
        {
            // traverse and get two elements
            traverse(root);
            // swap
            int temp = v1.val;
            v1.val = v2.val;
            v2.val = temp;
        }
        /*
         * julia's comment:
         * the violation in inorder traversal output is not written in most simple form.
         * Rewrite the second version traverse_B
         */
        private static void traverse(TreeNode t)
        {
            if (t == null)
            {
                return;
            }

            traverse(t.left);

            bool inIncreasingOrder = t.val > theLast.val;
            if (!inIncreasingOrder)  // not in increasing order
            {
                if (v1 == null)
                {
                    v1 = t;
                    v2 = theLast;   // this is the one - violation one.
                }
                else
                {
                    v1 = v2;
                    v2 = t;
                }
            }

            theLast = t;
            traverse(t.right);
        }
        /*
         *
         *  Base test case:
         *   tree only have two nodes, switched;
         *   case A:
         *      2          1
         *     /    ->    /
         *     1         2
         *   case B:
         *     1           2
         *      \    ->     \
         *      2            1
         *
         violation facts:
         *  1. first node, it is the one with bigger value, violated;
         *  but second node, it is the one with smaller value, violated.
         *  2. sometimes, only one violation catch; like base case A, switch two nodes, only two nodes
         *     in the tree. Tree [2,#,1]
          *  3. sometimes, two violationes catch.
         *     Tree [2, 3, 1], inorder traversal result is 3, 2, 1, and then,
         *     first one of viloations is 3, 2, 3>2, the violation one is 3, bigger value;
         *     second one of viloations is 2, 1, 2>1, the violation one is 1, smaller value;
         *     so, 3 and 1 should be swapped back as 1 (2) 3
         */
        private static void traverse_B(TreeNode t)
        {
            if (t == null)
            {
                return;
            }

            traverse(t.left);

            bool inIncreasingOrder = t.val > theLast.val;
            if (!inIncreasingOrder)  // not in increasing order
            {
                if (v1 == null)
                {
                    v1 = t;    // first violation node, with bigger value
                }

                v2 = theLast;  // second violation node, with smaller value
            }

            theLast = t;
            traverse(t.right);
        }