Leetcode 297. 二叉树的序列化与反序列化（DAY 23）（Hard细节挺多的 需要调试一会 含题解）

已于 2022-12-13 21:53:04 修改
阅读量304 收藏
点赞数
分类专栏： # Leetcode算法之路-Hard 从c开始的进步之路 文章标签： c语言
于 2021-01-11 20:56:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37500516/article/details/112452218
版权

文章目录

原题题目

在这里插入图片描述

代码实现（首刷绝大部分自解）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/** Encodes a tree to a single string. */
char* serialize(struct TreeNode* root){

//基本思路 层序遍历
if(!root)
        return NULL;
    char* tree = (char*)malloc(sizeof(char) * 100000);
    
    //这里的charpos是记录字符串当前到什么位置了
    int size = 0,rear = -1,top = -1,charpos = 0;
    struct TreeNode* queue[50000],*pos = root;
    queue[++rear] = pos;
    while(rear != top)
    {
        size = rear - top; 
        while(size--)
        {
            pos = queue[++top];
            if(!pos)
                charpos += sprintf(tree+charpos,",%s","null");
            else
            {
                if(!top)
                    charpos += sprintf(tree+charpos,"%d",pos->val);
                else
                    charpos += sprintf(tree+charpos,",%d",pos->val);
                    
				//当存在时 则导入其节点 不存在时 则放入NULL 方便检测
                if(pos->left) queue[++rear] = pos->left;
                else queue[++rear] = NULL;
                if(pos->right) queue[++rear] = pos->right;
                else queue[++rear] = NULL;
            }
        }
        //当只存在空结点时 则退出循坏
        if(rear - top == nullnumbers)
            break;
    }
    return tree;
}

/** Decodes your encoded data to tree. */
struct TreeNode* deserialize(char* data) {
if(!data)
        return NULL;
        
    //这里是设定最小值
    const int MIN = -99999;
    int numpos = 0,charpos = 0,num[50000],number,tempnumpos = 0,nextlevel;
    struct TreeNode* stack[50000],*realroot,*root;
    bool flag;//flag的作用是检测是否为负数 因为负数占两个格子

	//下面的while主要将有效数字提取出来 变成数组
    while(charpos < strlen(data))
    {
        flag = false;
        if(data[charpos] == ',')
            charpos++;
        number = 0;
        
        //当出现负数时
        if(data[charpos] == '-')
        {
            flag = true;
            charpos++;
        }
        if(data[charpos] >= '0' && data[charpos] <= '9')
        {
            while(data[charpos] >= '0' && data[charpos] <='9')
                number = number*10 + data[charpos++] - '0';
            if(!flag)
                num[numpos++] = number;
            else
                num[numpos++] = -number;
        }
        else
        {
            num[numpos++] = MIN;
            charpos += 4;
        }
    }

	//创建根节点
    realroot = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    realroot->val = num[tempnumpos];
    realroot->left = realroot->right = NULL;
    stack[tempnumpos] = realroot;

	//nextlevel的作用是 确定左右节点的在数组中的位置
    nextlevel = tempnumpos+1;

    while(tempnumpos < numpos)
    {
        if(num[tempnumpos] != MIN)
        {
            if(nextlevel < numpos && num[nextlevel] != MIN)
            {
                root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
                root->val = num[nextlevel];
                root->right = root->left = NULL;
                stack[tempnumpos]->left = root;
                stack[nextlevel] = root;
            }
            else
                stack[tempnumpos]->left = NULL;
            //向下移动位置
            nextlevel++;
            if(nextlevel < numpos && num[nextlevel] != MIN)
            {
                root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
                root->val = num[nextlevel];
                root->left = root->right = NULL;
                stack[tempnumpos]->right = root;
                stack[nextlevel] = root;
            }
            else
                stack[tempnumpos]->right = NULL;
            //向下移动位置
            nextlevel++;
        }
        tempnumpos++;
    } while(tempnumpos < numpos);
    return realroot;
}
// Your functions will be called as such:
// char* data = serialize(root);
// deserialize(data);

代码实现（二刷 DAY 167 C++ 双百）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        string ret;
        vector<TreeNode*> next,now;
        if(root)
        {
            now.emplace_back(root);
            ret += to_string(root->val);
            ret += ',';
        }
        while(now.size())
        {
            next.clear();
            for(const auto& ptr:now)
            {
                if(ptr->left)
                {
                    next.emplace_back(ptr->left);
                    ret += to_string(ptr->left->val);
                }
                else    ret.push_back('_');
                ret.push_back(',');
                if(ptr->right)
                {
                    next.emplace_back(ptr->right);
                    ret += to_string(ptr->right->val);
                }
                else    ret.push_back('_');
                ret.push_back(',');
            }
            now = next;
        }
        return ret;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data)
    {
        vector<int> num;
        string s;
        vector<TreeNode*> now,next;
        TreeNode* ret = nullptr;
        int pos = 0;
        for(const auto& chr:data)
        {
            if(chr == ',')
            {
                if(s.size())    num.emplace_back(stoi(s));
                s.clear();
            }
            else if(chr == '_')
                num.emplace_back(INT_MIN);
            else s.push_back(chr);
        }    

        if(data.empty())    return nullptr;
        ret = new TreeNode(num[0]);
        ++pos;
        now.emplace_back(ret);
        while(now.size())
        {
            next.clear();
            for(const auto& ptr:now)
            {
                if(num[pos] != INT_MIN)
                {
                    ptr->left = new TreeNode(num[pos]);
                    next.emplace_back(ptr->left);
                }
                if(num[pos+1] != INT_MIN)
                {
                    ptr->right = new TreeNode(num[pos+1]);
                    next.emplace_back(ptr->right);
                }
                pos += 2;
            }
            now = next;
        }
        return ret;
    }
};

// Your Codec object will be instantiated and called as such:
// Codec ser, deser;
// TreeNode* ans = deser.deserialize(ser.serialize(root));

代码实现（三刷自解 细节很多 需要多做 DAY 258 C++）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {
        string ret;
        queue<TreeNode*> queue;
        queue.emplace(root);

        while(!queue.empty())
        {
            int size = queue.size();
            for(int i = 0;i < size;++i)
            {
                auto root = queue.front();
                queue.pop();

                if(root)
                {
                    ret += to_string(root->val);
                    queue.emplace(root ? root->left : nullptr);
                    queue.emplace(root ? root->right : nullptr);
                }   
                else    ret += "_";
                ret += ',';
            }
        }

        return ret;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data)
    {
        string tmp;
        vector<int> v;
        for(const auto& chr:data)
        {
            if(chr == ',')
            {
                if(tmp.size())  v.emplace_back(stoi(tmp));
                tmp.clear();
                continue;
            }
            if(chr == '_')     v.emplace_back(INT_MAX);
            else               tmp += chr; 
        }

        int pos = 0,v_size = v.size();
        TreeNode* root = v[pos] == INT_MAX ? nullptr : new TreeNode(v[pos]);
        ++pos;
        queue<TreeNode*> queue;
        if(root)    queue.emplace(root);

        while(queue.size())
        {
            int size = queue.size();
            for(int i = 0;i < size;++i)
            {
                TreeNode* pre = queue.front();
                queue.pop();

                if(pre)
                {
                    pre->left =  (v[pos] == INT_MAX ? nullptr : new TreeNode(v[pos]));
                    pre->right = (v[pos + 1] == INT_MAX ? nullptr : new TreeNode(v[pos + 1]));
                    pos += 2;
                }

                if(pre->left)    queue.emplace(pre->left); 
                if(pre->right)   queue.emplace(pre->right);
            }
        }

        return root;
    }
};

代码实现（四刷自解 DAY 299 C++）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Codec {
 public:
  string serialize(TreeNode* root) {
    deque<TreeNode*> deque;
    deque.emplace_back(root);
    string ret;
    bool nextlevel = true;

    while (!deque.empty() && nextlevel) {
      int size = deque.size();
      nextlevel = false;
      for (int i = 0; i < size; ++i) {
        TreeNode* ptr = deque.front();
        deque.pop_front();
        
        if (!ptr) {
          ret += "_,";
          continue;
        } 

        ret += to_string(ptr->val);
        ret += ',';
        deque.emplace_back(ptr->left);
        deque.emplace_back(ptr->right);
        if (ptr->left || ptr->right) {
          nextlevel = true;
        }
      }
    }

    return ret;
  }

  int GetNextNum(const string& data, int& index) {
    if (index >= data.size()) return INT_MIN;
    if (data[index] == '_') {
      index += 2;
      return INT_MIN;
    }

    int num = 0;
    bool neg = false;
    if (data[index] == '-') {
      neg = true;
      ++index;
    } 
    while (index < data.size() && data[index++] != ',') {
      num *= 10;
      num += (data[index - 1] - '0');
    }
    if (neg) num = -num;
    return num;
  }

  // Decodes your encoded data to tree.
  TreeNode* deserialize(string data) {
    if (data.empty() || data[0] == '_') return nullptr;

    int index = 0;
    int num = GetNextNum(data, index);
    TreeNode* ret = new TreeNode(num);
    deque<TreeNode*> deque;
    deque.emplace_back(ret);

    while (index < data.size()) {
      int size = deque.size();
      for (int i = 0; i < size; ++i) {
        TreeNode* prev = deque.front();
        deque.pop_front();
        int leftnum = GetNextNum(data, index);
        int rightnum = GetNextNum(data, index);

        TreeNode* left = leftnum != INT_MIN ? new TreeNode(leftnum) : nullptr;
        TreeNode* right = rightnum != INT_MIN ? new TreeNode(rightnum) : nullptr;
        prev->left = left;
        prev->right = right;
        if (left) deque.emplace_back(left);
        if (right) deque.emplace_back(right);
      }
    }
    return ret;
  }
};

// Your Codec object will be instantiated and called as such:
// Codec ser, deser;
// TreeNode* ans = deser.deserialize(ser.serialize(root));

代码实现（五刷自解 DAY 11 Golang）

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
type Codec struct { 
}

func Constructor() Codec {
  return Codec{}
}

// Serializes a tree to a single string.
func (this *Codec) serialize(root *TreeNode) string {
  s := &strings.Builder{}
  if root == nil {
    s.WriteString("_,")
    return s.String()
  }

  deq := []*TreeNode{}
  deq = append(deq, root)
  
  for len(deq) != 0 {
    size := len(deq)
    for i := 0; i < size; i++ {
      ptr := deq[i]
      if ptr != nil {
        s.WriteString(strconv.Itoa(ptr.Val))
      } else {
        s.WriteByte('.')
      }
      s.WriteByte(',')
      if ptr != nil {
        deq = append(deq, ptr.Left)
        deq = append(deq, ptr.Right)
      }
    }
    deq = deq[size:]
  }
  return s.String()
}

// Deserializes your encoded data to tree.
func (this *Codec) deserialize(data string) *TreeNode {    
    if len(data) == 0 || data[0] == '_' {
      return nil
    }

    pos, nextpos := 0, 0
    for ; nextpos < len(data) && data[nextpos] != ','; nextpos++ {
    }
    var ret *TreeNode = nil
    if val, err := strconv.Atoi(data[pos:nextpos]); err == nil {
      ret = &TreeNode{Val : val}
    }
    pos, nextpos = nextpos + 1, nextpos + 1

    deq := []*TreeNode{}
    deq = append(deq, ret)
    
    for len(deq) != 0 {
      size := len(deq)
      judge := false
      for i := 0; i < size; i++ {
        ptr := deq[i]
        var left , right *TreeNode = nil, nil
        
        for ; nextpos < len(data) && data[nextpos] != ','; nextpos++ {
        }
        if val, err := strconv.Atoi(data[pos:nextpos]); err == nil {
          left = &TreeNode{Val : val}
          ptr.Left, deq = left, append(deq, left)
          judge = true
        }
        pos, nextpos = nextpos + 1, nextpos + 1

        for ; nextpos < len(data) && data[nextpos] != ','; nextpos++ {
        }
        if val, err := strconv.Atoi(data[pos:nextpos]); err == nil {
          right = &TreeNode{Val : val}
          ptr.Right, deq = right, append(deq, right)
          judge = true
        }
        pos, nextpos = nextpos + 1, nextpos + 1
      }
      deq = deq[size:]
      if judge == false {
        break
      }
    }
    return ret
}


/**
 * Your Codec object will be instantiated and called as such:
 * ser := Constructor();
 * deser := Constructor();
 * data := ser.serialize(root);
 * ans := deser.deserialize(data);
 */
Love 6
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LeetCode 331. 验证二叉树的前序序列化
12-21
序列化二叉树的一种方法是使用前序遍历。 当我们遇到一个非空节点时，我们可以记录下这个节点的值。 如果它是一个空节点，我们可以使用一个标记值记录，例如 #。 _9_ / \ 3 2 / \ / \ 4 1 # 6 / \ / \ / \ # # ...
【LeetCode力扣】297. 二叉树的序列化与反序列化
Hacynn的博客
10-15 1182
297. 二叉树的序列化与反序列化 - 力扣（LeetCode）二叉树序列化就是将内存中的二叉树变成硬盘中的字符串形式，并且要求每个二叉树能够对应一个唯一的字符串。二叉树反序列化就是将这个唯一字符串在内存中还原回对应的二叉树。
LeetCode-297. 二叉树的序列化和反序列化（最全解法）
weixin_40563850的博客
07-22 174
LeetCode-297. 二叉树的序列化和反序列化一、题目内容二、题解过程1、什么是序列化和反序列化2、遍历算法分析及实现框架3、解法解法一（前序遍历解法）：解法二（后续遍历解法）解法三（中续遍历解法）解法四（层级遍历解法） -.- 这题不会做，记录下大佬的题解（难度：中等） 一、题目内容 序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。 请设计一个算法来实现二叉树的序列化与反序列
⭐算法入门⭐《线性枚举》简单10 —— LeetCode 剑指 Offer 17. 打印从1到最大的n位数
英雄哪里出来
09-04 4719
《线性枚举》简单10 —— LeetCode 剑指 Offer 17. 打印从1到最大的n位数
【Leetcode】297. 二叉树的序列化与反序列化
锥栗的博客
05-09 143
题目描述 // 297. 二叉树的序列化与反序列化 // 序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换 // 后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机 // 环境，采取相反方式重构得到原数据。 // 请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序 // 列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这 // 个字符串反序列化为原始的树结构。 // 提示: 输入输出格式与 LeetCode 目前
leetcode：297. 二叉树的序列化与反序列化
OceanStar的博客
04-22 342
题目来源 leetcode 题目描述 、 题目解析 二叉树序列化的本质是对其进行编码，更重要的是对其结构进行编码。可以遍历树来完成上述任务。一般有两个策略：广度优先搜索和深度优先搜索 广度优先搜索可以按照层次从上往下遍历所有节点 深度优先搜索可以从一个根节点开始，一直延伸到某个叶，然后回到根，到达另一个分支。根据根节点、左节点和右节点之间的相对顺序，可以进一步将深度优先搜索策略区分为： 先序遍历 中序遍历 后序遍历 深度优先搜索 序列化： 递归遍历一棵树，重点关注当前节点，它的子树的遍
Leetcode 297：二叉树的序列化与反序列化（超详细的解法！！！）
coordinate的博客
10-18 1220
序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。 请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。 示例: 你可以将以下二叉树： 1 ...
LeetCode297：hard级别中最简单的存在，java版，用时击败98%，内存击败百分之九十九
程序员欣宸的博客
09-04 497
LeetCode的hard题都很难吗？不一定，297就非常简单，随本文一起，用最基础的知识写代码，执行用时能击败98.46%，与此同时，内存消耗击败99.73%
【leetcode-树】二叉树的序列化与反序列化
12-21
这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。 示例:  你可以将以下二叉树： 1 / \ 2 3 / \ 4 5 序列化为 "[1,2,3,...
java-leetcode面试题解Stack之第331题验证二叉树的前序序列化-题解.zip
最新发布
05-05
java java_leetcode面试题解Stack之第331题验证二叉树的前序序列化_题解
leetcode102. 二叉树的层次遍历
01-06
leetcode 102. 二叉树的层次遍历 给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。 例如: 给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20  / \  15 7 返回其层次遍历结果：...
tesla-peer#LeetCode-Python-#0428. 序列化和反序列化 N 叉树1
07-25
解题思路序列化：通过深度优先搜索的方式，递归遍历节点，以 root.val、len(root.children)、root.children 的顺序生成序列化结
LeetCode 297. 二叉树的序列化与反序列化
Aries_young的博客
04-07 746
题目描述 297. 二叉树的序列化与反序列化 解法： 我们知道要唯一确定一棵二叉树，要么是前序 + 中序，要么是中序 + 后序。但是，在这道题中前序遍历的结果记录了空指针的信息，那么就可以序列化结果唯一确定一棵二叉树 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x
297.二叉树的序列化与反序列化
zrh_CSDN的博客
11-05 286
序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。 请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。 示例:  你可以将以下二叉树： ...
LeetCode第 297 题：二叉树的序列化与反序列化(C++)
zj
09-02 322
297. 二叉树的序列化与反序列化 - 力扣（LeetCode） 前序遍历，dfs class Codec { public: // Encodes a tree to a single string. string serialize(TreeNode* root) {//先序遍历 if(!root) return "#_"; string res = to_string(root->val) + "_" + serialize(root->
leetcode297
剑似生平
06-01 131
题目： 序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。 请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。 示例: 你可以将以下二叉树： 1 / \ 2 3 / \ 4 5 序列化为 "[1,2,...
LeetCode第297题解析
blue_coffeei的博客
07-27 197
序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。 请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。 示例: 你可以将以下二叉树： 1 / \ 2 3 / \ 4 5 序列化为 "[1,2,3,nul.
Leetcode 224. 基本计算器（DAY 264）---- 后端面试题（双栈计算器 需要考虑边界）
Love 6's Private Blog
03-12 7453
文章目录原题题目代码实现（首刷自解） 原题题目 代码实现（首刷自解） class Solution { public: inline void cal(const char op,stack<int>& num_stack) { auto num1 = num_stack.top(); num_stack.pop(); auto num2 = num_stack.top(); num_stack.
leetcode 2031. 1 比 0 多的子数组个数
12-16
leetcode 2031题是一道有关于子数组的问题。问题的要求是求出给定数组中，1的个数比0多的子数组的个数。我们可以通过遍历数组的每个元素，然后计算以该元素结尾的子数组中，1的个数比0多的个数。 我们可以定义一个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Love 6

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值