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?

这道题的意思是本来有一颗BST，但是不小心把其中两个节点互换了，现在需要把这两个节点换回来，或者交换这两个节点的值也行，关键在于找到这两个互换节点

个人思路：

1、创建一个vector<TreeNode *> A，保存中序遍历的所有节点，由于原BST有两个节点互换了，那么该中序遍历的结果并不是递增的

2、再创建一个vector<TreeNode *> B，并用A的元素初始化B，然后为B排序，此时的B是递增顺序的（也即对调了互换节点的指针），遍历比较这两个vector的元素，当发现A的元素不等于B的元素时，表明两个不相等的元素就是那两个互换节点，找到这两个互换节点后，交换它俩的值即可

代码：

#include <stddef.h>
#include <vector>
#include <algorithm>

using namespace std;
/*
struct TreeNode
{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
*/
class Solution
{
public:
    void recoverTree(TreeNode *root)
    {
        vector<TreeNode *> inorderRaw;
        inorder(root, inorderRaw);
        vector<TreeNode *> inorderSorted(inorderRaw);
        sort(inorderSorted.begin(), inorderSorted.end(), Solution::cmp);
        vector<TreeNode *>::iterator raw = inorderRaw.begin();
        vector<TreeNode *>::iterator sorted = inorderSorted.begin();

        while (true)
        {
            if ((*raw)->val != (*sorted)->val)
            {
                break;
            }
            ++raw;
            ++sorted;
        }
        int tmp = (*raw)->val;
        (*raw)->val = (*sorted)->val;
        (*sorted)->val = tmp;
    }
    static bool cmp(const TreeNode *first, const TreeNode *second)
    {
        return first->val <= second->val;
    }
private:
    void inorder(TreeNode *root, vector<TreeNode *> &inorderRaw)
    {
        if (!root)
        {
            return;
        }
        inorder(root->left, inorderRaw);
        inorderRaw.push_back(root);
        inorder(root->right, inorderRaw);
    }
};
/*
int main()
{
    return 0;
}
*/

题目要求仅使用常数空间，上面的算法不和要求，上网看了几篇文章，找到了符合题意的算法（一开始我也是这么想的，但后来想岔了），链接：http://blog.163.com/ya_mzy/blog/static/19959325520137153340725/

思路：

1、这里我们先举个例子来说明，比如一个正常的BST中序遍历应该是递增的，如1234567，现在互换了两个节点3和6，变成1264537

2、那么，有什么特点呢？当中序遍历时，会有一个节点比后一个节点大，一个节点比前一个节点小，我们就要找到这两个节点，通过预设一个pre指针用于记录中序遍历的前一个节点即可，当这两个互换的节点相邻时，如1243567，仅会有一次当前节点小于前一节点的情况（一般会出现两次，第一次是前一节点，第二次是当前节点），这时这两个节点便是互换节点

代码：

#include <stddef.h>

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

class Solution
{
public:
    void recoverTree(TreeNode *root)
    {
        TreeNode *swappedElement1 = NULL;
        TreeNode *swappedElement2 = NULL;
        TreeNode *pre = NULL;

        findSwappedElements(root, pre, swappedElement1, swappedElement2);

        int tmp = swappedElement1->val;
        swappedElement1->val = swappedElement2->val;
        swappedElement2->val = tmp;
    }
private:
    void findSwappedElements(TreeNode *root, TreeNode *&pre, TreeNode *&swappedElement1, TreeNode *&swappedElement2)
    {
        if (!root)
        {
            return;
        }

        findSwappedElements(root->left, pre, swappedElement1, swappedElement2);

        if (pre && root->val < pre->val)
        {
            if (!swappedElement1)
            {
                swappedElement1 = pre;
                swappedElement2 = root;
            }
            else
            {
                swappedElement2 = root;
            }
        }

        pre = root;

        findSwappedElements(root->right, pre, swappedElement1, swappedElement2);
    }
};

int main()
{
    return 0;
}