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?

 

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

class Solution {

private:

    vector<TreeNode*> nodes;

public:

    void recoverTree(TreeNode *root) {

        nodes.clear();

        dfs(root);

        // 1 5 3 4 2 6 7

        // 1 3 2 4

        // 3 2

        int len = nodes.size();

        if (len < 1) return;

        

        int pre = nodes[0]->val;

        int cur = 0;

        int first = -1;

        int second= -1;

        for (int i=1; i<len; i++) {

            cur = nodes[i]->val;

            if (cur < pre) {

                if (first < 0) {

                    first = i-1;

                } else {

                    second= i;

                }

            }

            pre = cur;

        }

        if (second < 0) second = first + 1;

        int t = nodes[first]->val;

        nodes[first]->val = nodes[second]->val;

        nodes[second]->val= t;

    }

    

    void dfs(TreeNode* root) {

        if (root == NULL) return;

        dfs(root->left);

        nodes.push_back(root);

        dfs(root->right);

    }

};

先来个"A solution using O(n) space is pretty straight forward"的方法。如果递归调用栈不算额外空间的话，把先序遍历改一下即可，如果算的话...怎么办

来一个伪常数空间的：

/**

 * Definition for binary tree

 * struct TreeNode {

 *     int val;

 *     TreeNode *left;

 *     TreeNode *right;

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

 * };

 */

class Solution {

private:

    vector<TreeNode*> nodes;

    TreeNode* pre;

    TreeNode* first;

    TreeNode* second;

public:

    void recoverTree(TreeNode *root) {

        nodes.clear();

        pre = first = second = NULL;

        dfs(root);

        // case a. 1 5 3 4 2 6 7

        // case b. 1 3 2 4

        // case c. 3 2

        // case d. 3

        // case e. NULL

        if (second == NULL) return; // case (d,e)

        int t = first->val;

        first->val = second->val;

        second->val= t;

    }

    

    void dfs(TreeNode* root) {

        if (root == NULL) return;

        dfs(root->left);

        visit(root);

        dfs(root->right);

    }

    

    void visit(TreeNode* node) {

        if (pre == NULL) {

            pre = node;

            return;

        }

        if (node->val < pre->val) {

            if (first == NULL) {

                first = pre;

                second= node;   // assume swap with node next to pre(case b,c)

            } else {

                second= node;   // fix above assumption(case a)

            }

        }

        pre = node;

    }

};

 第二轮：

/**

 * 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 {

private:

    TreeNode* first;

    TreeNode* second;

    TreeNode* last;

public:

    void recoverTree(TreeNode* root) {

        last = first = second = NULL;

        dfs(root);

        swap(first->val, second->val);

    }

    

    void dfs(TreeNode* root) {

        if (root == NULL) {

            return;

        }

        dfs(root->left);

        

        if (last != NULL) {

            if (last->val > root->val) {

                if (first == NULL) {

                    first = last;

                }

                second = root;

            }

        }

        last = root;

        

        dfs(root->right);

    }

};