[LeetCode]Recover Binary Search Tree

struct TreeNode {
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
//the clue is that if we traverse the tree in inorder, then it must be sorted, so:
//1. the first error element must be the first element of the pair who breaks the order
//2. the second error element must be the second element of the pair who breaks the order
//note: there is a special case that the two element exist in one single error pair
public:
	void recoverTree(TreeNode *root) {
		// Start typing your C/C++ solution below
		// DO NOT write int main() function
		TreeNode* prev = NULL;
		TreeNode* e1 = NULL;
		TreeNode* e2 = NULL;
		GetErrorElement(root, e1, e2, prev);
		if(e1 && e2)
			swap(e1->val, e2->val);
	}

	void GetErrorElement( TreeNode * root, TreeNode*& e1, TreeNode*& e2, TreeNode*& prev ) 
	{
		//throw std::exception("The method or operation is not implemented.");
		if(!root)
			return;
		GetErrorElement(root->left, e1, e2, prev);
		if (prev && prev->val > root->val)
		{
			e2 = root;//second error element
			if(!e1)//first error element
				e1 = prev;
		}
		prev = root;
		GetErrorElement(root->right, e1, e2, prev);
	}
};

second time

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void recorverTreeUtil(TreeNode* root, TreeNode*& prev, TreeNode*& first, TreeNode*& mid, TreeNode*& second)
    {
        if(root == NULL) return;
        recorverTreeUtil(root->left, prev, first, mid, second);
        if(prev != NULL && prev->val > root->val)
        {
            if(first == NULL) first = prev, mid = root;
            else second = root;
        }
        prev = root;
        recorverTreeUtil(root->right, prev, first, mid, second);
    }
    void recoverTree(TreeNode *root) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        TreeNode* first = NULL;
        TreeNode* mid = NULL;
        TreeNode* second = NULL;
        TreeNode* prev = NULL;
        recorverTreeUtil(root, prev, first, mid, second);
        if(second != NULL) swap(first->val, second->val);
        else swap(first->val, mid->val);
    }
};