【Leetcode 99】 Recover BST

[Leetcode 99] Recover BST

要求:

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?

题意：

把顺序二叉树(二叉搜索树) 放错的两个元素交换一下位置。

解法：

二叉树是要考虑单个元节点跟它的左右子树的关系的。本题中的关系可能是左右子树中的节点有问题，但也可能是该节点跟子树中的一个调换了。

想要调换两个值，必须找出有问题的两个值。二叉树的中序遍历可以让我们用vector保存遍历的所有元素。这是O(n)空间复杂度的方法。另一种做法是Morris中序遍历，其实是用相邻节点指针遍历整颗树，过程中保存有问题的节点。这个遍历过程叫做线索树(threaded tree)。

时间复杂度O(n)。

代码:

class Solution {
    public:
    void recoverTree(TreeNode* root) {
        if (root == NULL) return;
        if (root->left == NULL && root->right == NULL) return;
        TreeNode* prev = NULL;
        // to save the result
        pair<TreeNode*, TreeNode*> broken;
        broken.first = NULL;
        TreeNode* cur = root;
        traversal(broken, cur, prev);
        swap(broken.first->val, broken.second->val);
    }
    void traversal(pair<TreeNode*, TreeNode*> & broken, TreeNode* cur, TreeNode*& prev) {
        if (cur) {
            if (cur->left != NULL) {
                // 遍历左树, 更新prev
                traversal(broken, cur->left, prev);
            }
            if (prev != NULL && prev->val > cur->val) {
                // 保存第一个错误节点
                if (broken.first == NULL) {
                    broken.first = prev;
                    broken.second = cur;
                } else {
                // 保存第二个错误节点
                    broken.second = cur;
                }
            }
            prev = cur;
            if (cur->right != NULL) {
                traversal(broken, cur->right, prev);
            }
        }
    }
};

测试：

class Solution0 {
public:
    // the following is used to generate test examples for inorderTraversal
    TreeNode* buildTree(vector<int> P, vector<int> T) {
        if (P.size() != T.size()) return NULL;
        int len = P.size();
        TreeNode* root = helper(P, T, 0, len - 1, 0, len - 1);
        return root;
    }
    // This is used for creating a tree by inputting preorder and inorder tree.
    TreeNode* helper(vector<int>& P, vector<int>& T, int pt, int pd, int st, int ed) {
        // cout << "st ed = " << st << " " << ed << endl;
        // cout << "pt pd = " << pt << " " << pd << endl;
        if (st > ed) return NULL;
        TreeNode* root = new TreeNode(0);
        int val = P[pt], len = P.size();
        for (int i = st; i <= ed; i++) {
            if (T[i] == val) {
                root->left = helper(P, T, pt + 1, pt + i - st, st, i - 1);
                root->val = val;
                root->right = helper(P, T, pt + i - st + 1, pd, i + 1, ed);
                break;
            }
        }
        return root;
    }
    void traverse(TreeNode* next, int dep) {
        if (next == NULL) {
            for (int i = 0; i < dep; i++) {
                printf("  ");
            }
            printf("NULL\n");
            return;
        }
        if (dep == 0) printf("     -:");
        for (int i = 0; i < dep; i++) {
            printf("  ");
        }
        cout << next->val << " " << next << endl;

        printf("left -:");
        traverse(next->left, dep + 1);
        printf("right-:");
        traverse(next->right, dep + 1);
    }
};
int main() {
    int n;
    Solution0 sol2;
    while (cin >> n) {
        vector<int> inorder(n, 0), preorder(n, 0);
        for (int i = 0; i < n; i++)  {
            cin >> preorder[i];
        }
        for (int i = 0; i < n; i++) {
            cin >> inorder[i];
        }
        Solution sol;
        TreeNode* root2 = sol2.buildTree(preorder, inorder);
        sol.recoverTree(root2);
        sol2.traverse(root2, 0);
    }
    return 0;
}