Recover Binary Search Tree [LeetCode]

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?

Sulotion: Considers a BST as a storted array, so we can traverse the BST inorderly just like iterate the ascending sequence. In this way, we can easily find two elements swapped by mistake, then swaps them back.

    void inorder(TreeNode * root, TreeNode ** error_node, TreeNode ** pre_node, int * is_swap){
         if( root == NULL )
             return;
         if(root->left != NULL)
             inorder(root -> left, error_node, pre_node, is_swap);

         if((*pre_node) != NULL) {
             if ((*pre_node)->val > root->val){
                 if ((*error_node) == NULL)
                     *error_node = *pre_node;
             }else if( (*error_node) != NULL && (*error_node)->val < root->val && (*error_node)->val > (*pre_node )->val){
                 //swap error node and pre node
                 int tmp = (*error_node)->val;
                 (*error_node )->val = (*pre_node)->val;
                 (*pre_node)->val = tmp;
                 *is_swap = ;
                 return;
              }
         }

         (*pre_node )= root;   

         if( root -> right != NULL)
             inorder(root -> right, error_node, pre_node, is_swap);
     }

     void recoverTree(TreeNode *root) {
         // Note: The Solution object is instantiated only once and is reused by each test case.
         TreeNode * error_node = NULL;
         TreeNode * pre_node = NULL;
         int is_swap = ;
         inorder(root, &error_node, &pre_node, &is_swap);
         if ( is_swap ==  && error_node != NULL){
             int tmp = error_node -> val;
             error_node -> val = pre_node -> val;
             pre_node -> val = tmp;
         }
     }