LeetCode99 Recover Binary Search Tree

Two elements of a binary search tree (BST) are swapped by mistake.

Recover the tree without changing its structure. （Hard）

Note:
A solution using O(n) space is pretty straight forward. Could you devise a constant space solution?

分析：

BST的中序遍历应该是递增的，我们考虑这样一个中序遍历序列1,2,6,4,5,3,7，其中3,6是交换了位置的。

所以我们就按照中序遍历的顺序遍历树，记录cur, prev, beforePrev三个变量；

第一次出现before < prev > cur的prev即为要交换的第一个元素，最后一个满足beforePrev > prev < cur的即为要交换的另一个元素。

然后再遍历一遍把这两个节点找出来，交换其value值即可。

注意：比如1,0这种样例，当最后一个节点是被交换的元素的时候，无法用上述判断，但如果其满足prev > cur说明cur即为要交换的元素。

代码：

 /**
  * Definition for a binary tree node.
  * struct TreeNode {
  *     int val;
  *     TreeNode *left;
  *     TreeNode *right;
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
 class Solution {
     int beforePrev = -0x7FFFFFFF, prev = -0x7FFFFFFF, cur = -0x7FFFFFFF;
     int s1 = -0x7FFFFFFF, s2 = -0x7FFFFFFF;
     TreeNode* t1;
     TreeNode* t2;
 private:
     void helper(TreeNode* root) {
         if (root == nullptr) {
             return;
         }
         helper(root -> left);
         beforePrev = prev;
         prev = cur;
         cur = root -> val;
         if (beforePrev < prev && prev > cur && s1 == -0x7FFFFFFF) {
             s1 = prev;
         }
         if (beforePrev > prev && prev < cur ) {
             s2 = prev;
         }

         helper(root -> right);
     }

     void dfs(TreeNode* root) {
         if (root == nullptr) {
             return;
         }
         dfs(root -> left);
         if (root -> val == s1) {
             t1 = root;
         }
         if (root -> val == s2) {
             t2 = root;
         }
         dfs(root -> right);
     }
 public:
     void recoverTree(TreeNode* root) {
         helper(root);
         if (cur < prev) {
             s2 = cur;
         }
         dfs(root);
         swap(t1 -> val, t2 -> val);
         return;
     }
 };