【Recover Binary Search Tree】cpp

题目:

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.

代码:

/**
 * 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 {
public:
    void recoverTree(TreeNode* root) {
            if (!root) return;
            TreeNode *pre, *curr, *first=NULL, *second=NULL;
            stack<TreeNode *> sta;
            TreeNode *dummy = new TreeNode(INT_MIN);
            dummy->left = root;
            pre = dummy;
            curr = root;
            while ( !sta.empty() || curr )
            {
                if (curr){
                    sta.push(curr);
                    curr = curr->left;
                }
                else{
                    curr = sta.top();
                    sta.pop();
                    if ( !first ){
                        if ( pre->val > curr->val ){
                            first = pre;
                            second = curr;
                        }
                    }
                    else{
                        if ( curr->val < pre->val ){
                            second = curr;
                            break;
                        }
                    }
                    pre = curr;
                    curr = curr->right;
                }
            }
            std::swap(first->val, second->val);
    }
};

tips:

二叉查找树的中序遍历就是从小到大的输出(http://zh.wikipedia.org/wiki/二元搜尋樹)。

即从中序遍历的结果中找到两个需要交换的点。

为了简便,这里设定了虚根节点(初始化值为INT_MIN)保证不影响中序遍历的结果。具体的思想都参考的(http://www.cnblogs.com/TenosDoIt/p/3445682.html)。

通过这道题回顾了一下中序遍历的方法,并纠正了之前的中序遍历的一种自毁型的代码

http://www.cnblogs.com/xbf9xbf/p/4501655.html

在上面这道题中,写了一个自毁型的中序遍历代码(即中序遍历结束后,整个二叉树的所有节点都断了)。

在本道题中一开始沿用了这种自毁型的中序遍历代码,结果就可想而知了。通过这个点,给自己提个醒:以后再涉及到遍历这类的代码,尽量不要再写这种遍历一次就毁坏了数据结构的代码了。 

===========================================

第二次过这道题,直接学习的原来的代码。AC之后弄清楚了两个点:

(1)中序遍历是个模板,对BST的操作很多都依赖中序遍历。所以不管有没有first和second都要注意把中序遍历的代码写全了

(2)为什么找到第一个是first=pre而找到第二个是second=curr呢?曾就这个问题纠结过,后来猜测背后的思路可能是这样的:

   由于BST的两个节点位置错乱了,那么中序遍历必然有前面的节点要大于后面的。因此找到第一个不符合BST条件的,pre肯定是first;找到第二个不符合条件的curr肯定是second。

   另外还有一种特殊情况,就是被错位的两个点是挨着的,这样就更直接了。pre肯定是frist,curr肯定是second。

/**
 * 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 {
public:
    void recoverTree(TreeNode* root) {
            stack<TreeNode*> sta;
            TreeNode* first=NULL;
            TreeNode* second=NULL;
            TreeNode dummpy(INT_MIN);
            dummpy.left = root;
            TreeNode* pre = &dummpy;
            TreeNode* curr = root;
            while ( !sta.empty() || curr )
            {
                if ( curr )
                {
                    sta.push(curr);
                    curr = curr->left;
                }
                else
                {
                    curr = sta.top();
                    sta.pop();
                    if ( !first )
                    {
                        if (curr->val<pre->val)
                        {
                            first = pre;
                            second = curr;
                        }
                    }
                    else
                    {
                        if ( curr->val<pre->val)
                        {
                            second = curr;
                            break;
                        }
                    }
                    pre = curr;
                    curr = curr->right;
                }
            }
            std::swap(first->val, second->val);
    }
};

============================================================

第三次过这道题,本来不想粘代码了,但前几次的代码实在太冗余了,于是贴一版新的。

/**
 * 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 {
public:
    void recoverTree(TreeNode* root) {
        stack<TreeNode*> sta;
        TreeNode *pre = new TreeNode(INT_MIN);
        TreeNode *curr = root;
        TreeNode *n1=NULL, *n2=NULL;
        while ( !sta.empty() || curr )
        {
            if ( curr )
            {
                sta.push(curr);
                curr = curr->left;
            }
            else
            {
                curr = sta.top(); sta.pop();
                if ( pre->val > curr->val )
                {
                    if ( !n1 )
                    {
                        n1 = pre;
                        n2 = curr;
                    }
                    else
                    {
                        n2 = curr;
                        break;
                    }
                }
                pre = curr;
                curr = curr->right;
            }
        }
        if (n1) swap(n1->val, n2->val);
    }
};

 

posted on 2015-05-14 22:34  承续缘  阅读(269)  评论(0编辑  收藏  举报

导航