BM39 序列化二叉树

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
//
class Solution {
public:
    static int depTree(TreeNode *root,int dep)
    {
        if(root==NULL)
        {
            return dep;
        }
        else
        {
            int l=depTree(root->left,dep+1);
            int r=depTree(root->right,dep+1);
            return max(l,r);

        }
    }
    char* Serialize(TreeNode *root){    
        int dep=depTree(root,0);
        // printf("%d ",dep);
        string ss;
        static char a[105];
        queue<TreeNode*>qu;
        qu.push(root);
        int num=0;
        TreeNode *k=(TreeNode*)malloc(sizeof(TreeNode));
        k->val=35;
        k->left=NULL;
        k->right=NULL; 
        
        if(root==NULL)
        {
            strcpy(a,ss.c_str());
            return a;
        } 
        else if(root->right==NULL && root->left==NULL)
        {
            ss[0]=root->val;
            ss[1]='\0';
            strcpy(a,ss.c_str());
            return a;
            
        }
        else{
            for(int i=0;i<dep;i++)
            {
                queue<TreeNode*>qu1;
                if(i==dep-1)
                {
                     while(!qu.empty())
                    {
                        TreeNode *m=qu.front();
                        qu.pop();
                        if(m->val==35) 
                        {
                             ss[num++]=35;

                        }
                        else
                        {
                            ss[num++]=m->val;
                        }

                     }

                }
                else{
                        while(!qu.empty())
                        {
                            TreeNode *m=qu.front();
                            qu.pop();
                            
                            if(m->val==35) 
                            {
                                  ss[num++]=35;
                                  continue;
                            }
                            else
                            {
                             ss[num++]=m->val;
                             if(m->left==NULL)
                             {
                                 qu1.push(k);
                             }
                             else{
                                 qu1.push(m->left);
                             }
                             if(m->right==NULL)
                             {
                                 qu1.push(k);
                             }
                             else{
                                 qu1.push(m->right);
                             }
                           

                            }

                        }
                        qu=qu1;

                   }
               

            }
            ss[num]='\0';
            strcpy(a,ss.c_str());
            return a;
            
            
        }
    }
    TreeNode* Deserialize(char *str) {
        int n=0;
        while(str[n]!='\0')
        {
            n++;
        }
        char a=str[0];
        if(a=='\0') return NULL;
        int sum=0;
        TreeNode* root=(TreeNode*)malloc(sizeof(TreeNode));
        
        TreeNode* p=root;
        int j=2;
        root->val=(a+256)%256;
        root->left=NULL;
        root->right=NULL;
        if(n==1) return root;
        int num=1;
        queue<TreeNode*>qu;
        qu.push(root);
        while(true)
        {
            queue<TreeNode*>qu1;
            while(!qu.empty())
            {
                TreeNode *p=qu.front();
                qu.pop();
                 if(str[num]==35)
                 {
                     num++;
                     p->left=NULL;
                 }
                 else{
                      TreeNode* left1=(TreeNode*)malloc(sizeof(TreeNode));
                      left1->val=(str[num++]+256)%256;
                      left1->left=NULL;
                      left1->right=NULL;
                      p->left=left1;
                      qu1.push(left1);
                 }
                  if(str[num]==35)
                 {
                     num++;
                     p->right=NULL;
                 }
                 else{
                      TreeNode* right1=(TreeNode*)malloc(sizeof(TreeNode));
                      right1->val=(str[num++]+256)%256;
                      right1->left=NULL;
                      right1->right=NULL;
                      p->right=right1;
                      qu1.push(right1);
                 }
                 if(num==n) return root;
            }
            qu=qu1;
            if(qu1.empty()) return root;
        }



        // return NULL;
    }
};