Leetcode-Recover Binary Search Tree

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?

Code

#include <iostream>#include <list>#include <unordered_set>#include <vector>#include <algorithm>#include <algorithm>#include <random>#include <functional>#include <string>#include <memory>#include <stdexcept>      // std::out_of_range#include <stack>using namespace std;  struct TreeNode {      int val;      TreeNode *left;      TreeNode *right;      TreeNode(int x) : val(x), left(NULL), right(NULL) {}  };typedef TreeNode* tptr;vector<tptr> vs;void maxTree(tptr root, tptr &res) {    if (!root)return;    if (root->val > res->val) {        res = root;    }     maxTree(root->left, res);    maxTree(root->right, res);    return;}void minTree(tptr root, tptr &res) {    if (!root)return;    if (root->val < res->val) {        res = root;    }     minTree(root->left, res);    minTree(root->right, res);    return;}tptr minTreeR(tptr root) {    if (!root)return root;    auto p = root->right;    if (!p)return root;    else {        minTree(root->right, p);    }    return p;}tptr maxTreeL(tptr root) {    if (!root)return root;    auto p = root->left;    if (!p)return root;    else {        maxTree(root->left, p);    }    return p;}class Solution {public:    void exchangeNode(tptr p1, tptr p2) {        auto tmp = p1->val;        p1->val = p2->val;        p2->val = tmp;        //cout << tmp << endl;        return;    }    void recoverTree(TreeNode* root) {        if(!root)return;        auto med = root;        auto left = maxTreeL(med), right = minTreeR(med);        // case 1        if (left == right)return;        if (left == med) {           // cout << "l" << endl;           // cout << (long)left << " " << (long)med << " " << (long)right << endl;            if (med->val < right->val) return recoverTree(med->right);            else {                exchangeNode(med, right);                return;            }        } else if(right == med) {            if (med->val > left->val) {                recoverTree(med->left);            }            else {                exchangeNode(med, left);            }        } else {            // 1            if (left->val < med->val && med->val < right->val) {                recoverTree(med->left);                recoverTree(med->right);            }             else if (left->val>med->val && med->val > right->val)  {                exchangeNode(left, right);            }            else if (left->val > med->val) {                exchangeNode(left, med);            }            else {                exchangeNode(right, med);            }        }        return;    }};int main(){    vector<shared_ptr<TreeNode>> desTree;    auto p = make_shared<TreeNode>(3);    desTree.push_back(p);    auto p1  = make_shared<TreeNode>(2);    p->right = p1.get();    desTree.push_back(p1);    auto p2  = make_shared<TreeNode>(1);    p1->right = p2.get();    desTree.push_back(p2);    Solution so;    so.recoverTree(p.get());    cout << p->val << " "<<  p->right->val << " "<<p->right->right->val << endl;    return 0;}