剑指offer-序列化二叉树

问题

题目：[剑指offer-序列化二叉树]

思路

先说一下，下面的代码没有过，但是思路是对的。
我要求序列必须给出完全二叉树的形式，这样我才能计算正确的下表。但是题目序列化的时候，不是这么给的。我参考了一些网上做法，大家对序列化这个东西都是有自己的定义。

本质就是根据完全二叉树序列进行构建，然后广度优先遍历。

代码

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    char* Serialize(TreeNode *root) {    
        if(!root) return NULL;
        string ret;

        ret += (char)('0'+root->val);
        queue<TreeNode*> que;
        que.push(root);

        while(!que.empty()){
            root = que.front();
            que.pop();

            if( root->left ){
                ret += (char)('0'+root->left->val);
                que.push(root->left);
            }
            else
                ret += '#';

            if(root->right){
                ret += (char)('0'+root->right->val);
                que.push(root->right);
            }
            else
                ret += '#';
        }
        int sz = ret.size();
        int idx = sz - 1;
        while(ret[idx]=='#') --idx;
        string tmp = ret.substr(0, idx+1);
        return const_cast<char*>(tmp.c_str());

    }
    TreeNode* Deserialize(char *str) {
        if(!str) return NULL;
        return create_bitree( str, 0, strlen(str)-1 );
    }
private:
    TreeNode* create_bitree(char* str, int cur, int n){
        if( cur > n ) return NULL;
        if( str[cur] == '#' ) return NULL;

        TreeNode* root = new TreeNode( str[cur] - '0' );
        root->left = create_bitree( str, cur*2+1, n );
        root->right = create_bitree( str, cur*2 + 2, n );

        return root;
    }
};

思路２

今天二刷了这个题目，还是没有过。昨天末尾的时候，我想到了，可能是大家对于序列化的序列有不同的定义，所以导致不同的做法。今天我采用先序遍历的方法产生序列化。其中当左子树为空，但是右子树不为空的情形，需要添加＃

代码

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    char* Serialize(TreeNode *root) {    
        string ans;
        pre_order( root, ans );

        return const_cast<char*>( ans.c_str() );
        //return ans;
    }
    TreeNode* Deserialize(char *str) {
        if( !str ) return NULL;
        int cur = 0;
        int n = strlen(str);

        return create_bitree( str, cur, n );
    }
private:
    TreeNode* create_bitree(char* arr, int& cur, int n){
        if( cur >= n || arr[cur] == '#' ) return NULL;
        else{
            TreeNode* root = new TreeNode( arr[cur] ); ++cur;
            root->left = create_bitree( arr, cur, n );
            root->right = create_bitree( arr, cur, n  );
            return root;
        }
    }
    int pre_order(TreeNode* root, string& ans){
        if(!root) return -1;
        else{
            ans += static_cast<char>(root->val);

            int ret = pre_order( root->left, ans );
            if(-1==ret && root->right){
                ret+='#';
            }

            pre_order( root->right, ans );


            return 0;
        }
    }
};

---

这是一个过了的链接[《剑指offer》序列化二叉树]