二叉树序列化和反序列化的两种方式

最新推荐文章于 2024-05-16 14:02:04 发布
最新推荐文章于 2024-05-16 14:02:04 发布
阅读量4.7k 收藏 24
点赞数 2
分类专栏： 数据结构和算法及其应用 文章标签： 二叉树 算法 数据结构 java 序列最小化优化算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljfirst/article/details/109466318
版权

介绍

二叉树的序列化和反序列化，有两种方式：

  • 第一种方式在将二叉树序列化为数组的时候，需要标记空指针为特殊符号，这样在反序列化的时候，就可以根据这些符号和序列方式来确定一颗二叉树。
  • 第二种方式在序列化的时候，不需要标记特殊符号，这样序列化出来的就是一个纯数组或者字符串，但是这样的数组即使知道序列方式，也是无法反序列化出来的，必须使用中序+先序，或者中序+后续的两个数组，才能将其反序列化。

值的你关注并提升你薪资待遇的面试算法：开源数据结构和算法实践

目录

二叉树的序列化

按层遍历二叉树 输出数组

  • 设计思路
    • 通过队列的先进先出来构建父节点的弹出顺序
    • 通过双指针的对比来判断层级顺序
  • 主要代码
public void Binary2ArrayLevel_print(BinaryTreeImpl root) {
    if (check(root)) {
        return;
    }
    Queue<BinaryTreeImpl> queue = new LinkedList<>();
    queue.offer(root);
    BinaryTreeImpl front = root;
    BinaryTreeImpl tail = root;
    while (!queue.isEmpty()) {
        BinaryTreeImpl binaryTree = queue.poll();
        System.out.print(binaryTree.value + " ");
        if (binaryTree.left != null) {
            queue.offer(binaryTree.left);
            tail = binaryTree.left;
        }
        if (binaryTree.right != null) {
            queue.offer(binaryTree.right);
            tail = binaryTree.right;
        }
        if (binaryTree == front) {
            front = tail;
            System.out.println();
        }
    }
}
  • 注意事项
    • where的判断条件
    • 子节点判空
    • 输出层级的位置

S形遍历二叉树 输出数组

  • 设计思路
    • 利用双栈的特点，来交替打印输出的层级元素
  • 主要代码
public int[] Binary2ArrayS(BinaryTreeImpl root) {
    if (check(root)) {
        return new int[0];
    }
    List<Integer> list = new ArrayList<>();
    Stack<BinaryTreeImpl> stack1 = new Stack();
    Stack<BinaryTreeImpl> stack2 = new Stack();
    stack1.push(root);
    list.add(root.value);
    boolean rawflag = true;

    while (!stack1.empty() || !stack2.empty()) {
        while (!stack1.empty()) {
            BinaryTreeImpl node = stack1.pop();
            if (rawflag) {
                if (node.left != null) {
                    stack2.push(node.left);
                    list.add(node.left.value);
                }
                if (node.right != null) {
                    stack2.push(node.right);
                    list.add(node.right.value);
                }
            } else {
                if (node.right != null) {
                    stack2.push(node.right);
                    list.add(node.right.value);
                }
                if (node.left != null) {
                    stack2.push(node.left);
                    list.add(node.left.value);
                }
            }
        }
        rawflag = !rawflag;
        stack1 = stack2;
        stack2 = new Stack<>();
    }
    int[] binaryTrees = list.stream().mapToInt(Integer::intValue).toArray();
    return binaryTrees;
}
  • 注意事项
    • 标识位rawflag需要在每次层级关系结束的时候，反转一次
    • 层级关系结束的时候，双栈需要交换一次

先序遍历二叉树 输出数组

  • 设计思路
    • 先序遍历的特点是，先跟节点，再左孩子，后右孩子
  • 主要代码
//先序递归
public void PreOrder_recursion(BinaryTreeImpl root) {
    if (root == null) {
        return;
    }
    listPreOrder.add(root.value);
    if (root.left != null) {
        PreOrder_recursion(root.left);
    }
    if (root.right != null) {
        PreOrder_recursion(root.right);
    }
}
  • 一直遍历左孩子，再弹出右孩子
//先序非递归
public void PreOrder_stack(BinaryTreeImpl root) {
    Stack<BinaryTreeImpl> stack = new Stack();
    while (root != null || !stack.empty()) {
        while (root != null) {
            stack.push(root);
            listPreOrder.add(root.value);
            root = root.left;
        }
        root = stack.pop().right;
    }
}
  • 注意事项

中序遍历二叉树 输出数组

  • 设计思路
    • 中序遍历的特点是，先左孩子，再跟节点，最后右孩子
  • 主要代码
//中序递归
private void InOrder_recursion(BinaryTreeImpl root) {
    if (root == null) {
        return;
    }
    InOrder_recursion(root.left);
    listInOrder.add(root.value);
    InOrder_recursion(root.right);
}

//中序非递归
private void InOrder_stack(BinaryTreeImpl root) {
    Stack<BinaryTreeImpl> stack = new Stack<>();
    while (root != null || !stack.empty()) {
        while (root != null) {
            stack.push(root);
            root = root.left;
        }
        root = stack.pop();
        listInOrder.add(root.value);
        root = root.right;
    }
}
  • 注意事项
    • 中序非递归中需要注意list加入节点的时机

后序遍历二叉树 输出数组

  • 设计思路
    • 后序遍历的特点是，先左孩子，再右孩子，最后跟节点
  • 主要代码
//后续遍历 递归
private void PostOrder_recursion(BinaryTreeImpl root) {
    if (check(root)) {
        return;
    }
    PostOrder_recursion(root.left);
    PostOrder_recursion(root.right);
    listPostOrder.add(root.value);
}
  • 后续遍历 双栈法在遍历的时候，看似stack1是跟节点，左孩子，右孩子的顺序入栈，实则在导出至stack2的时候，是右孩子、左孩子、跟节点的顺序。
//后续遍历 双栈法
private void PostOrder_stack2(BinaryTreeImpl root) {
    Stack<BinaryTreeImpl> stack1 = new Stack<>();
    Stack<BinaryTreeImpl> stack2 = new Stack<>();
    stack1.push(root);
    while (!stack1.empty()) {
        root = stack1.pop();
        stack2.push(root);
        if (root.left != null) {
            stack1.push(root.left);
        }
        if (root.right != null) {
            stack1.push(root.right);
        }
    }
    while (!stack2.empty()) {
        listPostOrder.add(stack2.pop().value);
    }
}

//后续遍历 单栈法
public void PostOrder_stack1(BinaryTreeImpl h) {
    Stack<BinaryTreeImpl> stack = new Stack<>();
    stack.push(h);
    BinaryTreeImpl c = null;
    while (!stack.isEmpty()) {
        c = stack.peek();
        if (c.left != null && h != c.left && h != c.right) {
            stack.push(c.left);
        } else if (c.right != null && h != c.right) {
            stack.push(c.right);
        } else {
            listPostOrder.add(stack.pop().value);
            h = c;
        }
    }
}
  • 注意事项
    • 单栈法的h是上一个节点的位置，用于标记自身是否被重复入栈。

先序遍历二叉树 输出数组(特殊符号)

  • 设计思路
    • 递归
  • 主要代码
public int[] Binary2ArrayPreOrder_Symbol(BinaryTreeImpl root) {
        if (check(root)) {
            return new int[]{};
        }
        listPreOrder_Symbol = new ArrayList<>();
        PreOrder_Symbol(root);
        return listPreOrder_Symbol.stream().mapToInt(x -> x).toArray();
    }

    private void PreOrder_Symbol(BinaryTreeImpl root) {
        if (root == null) {
            listPreOrder_Symbol.add(Symbol);
            return;
        }
        listPreOrder_Symbol.add(root.value);
        PreOrder_Symbol(root.left);
        PreOrder_Symbol(root.right);
    }

中序遍历二叉树 输出数组(特殊符号)

  • 设计思路
    • 递归
  • 主要代码
public int[] Binary2ArrayInOrder_Symbol(BinaryTreeImpl root) {
    if(check(root)){
        return new int[]{};
    }
    listInOrder_Symbol = new ArrayList<>();
    InOrder_Symbol(root);
    return  listInOrder_Symbol.stream().mapToInt(Integer::intValue).toArray();
}

private void InOrder_Symbol(BinaryTreeImpl root){
    if(root == null){
        listInOrder_Symbol.add(Symbol);
        return;
    }
    InOrder_Symbol(root.left);
    listInOrder_Symbol.add(root.value);
    InOrder_Symbol(root.right);
}

后序遍历二叉树 输出数组(特殊符号)

  • 设计思路
    • 递归
  • 主要代码
public int[] Binary2ArrayPostOrder_Symbol(BinaryTreeImpl root) {
        if(check(root)){
            return new int[]{};
        }
        listPostOrder_Symbol = new ArrayList<>();
        PostOrder_Symbol(root);
        return listPostOrder_Symbol.stream().mapToInt(Integer::intValue).toArray();
    }

    private void PostOrder_Symbol(BinaryTreeImpl root){
        if(root==null){
            listPostOrder_Symbol.add(Symbol);
            return;
        }
        PostOrder_Symbol(root.left);
        PostOrder_Symbol(root.right);
        listPostOrder_Symbol.add(root.value);
    }

二叉树的反序列化

将按层次遍历的方式输入的数组 构造成一个二叉树

  • 设计思路
    • 通过队列辅助，实现节点顺序
  • 主要代码
//1、将按层次遍历的方式输入的数组  构造成一个二叉树(写法一：非递归，堆栈)
public BinaryTreeImpl createBinaryTreeLevel(int[] array) {
    if (!check(array)) {
        return null;
    }
    BinaryTreeImpl root = null;
    //借助队列实现
    Queue<BinaryTreeImpl> queue = new LinkedList();
    int depth = 0;
    root = new BinaryTreeImpl(array[depth]);
    queue.offer(root);
    while (!queue.isEmpty()) {
        BinaryTreeImpl binaryTree = queue.poll();
        //left child exist
        if (++depth < array.length && array[depth] != -1) {
            binaryTree.left = new BinaryTreeImpl(array[depth]);
            queue.offer(binaryTree.left);
        }
        //right child exist
        if (++depth < array.length && array[depth] != -1) {
            binaryTree.right = new BinaryTreeImpl(array[depth]);
            queue.offer(binaryTree.right);
        }
    }
    return root;
}
  • 使用递归实现，但是需要注意，此处的count是必须是全局变量。
//1、将按层次遍历的方式输入的数组  构造成一个二叉树(写法二:递归)
private volatile int count;
public BinaryTreeImpl createBinaryTreeLevel(BinaryTreeImpl root, int[] tree_num, int i) {
    if (i < tree_num.length) {
        if (tree_num[i] == -1) {
            return null;
        } else {
            //new root's lchild and rchild
            BinaryTreeImpl lchild = new BinaryTreeImpl();
            BinaryTreeImpl rchild = new BinaryTreeImpl();
            //preOrder
            root.value = tree_num[i];
            root.left = createBinaryTreeLevel(lchild, tree_num, ++count);
            root.right = createBinaryTreeLevel(rchild, tree_num, ++count);
        }
    }
    return root;
}
  • 注意事项
    • count是必须是全局变量。

将按先序遍历的方式输入的数组 构造成一个二叉树

  • 设计思路
    • 通过队列记录数组顺序
    • 先序构造二叉树
  • 主要代码
public BinaryTreeImpl createPreOrder(int[] array) {
    Queue<BinaryTreeImpl> queue = new LinkedList<>();
    if (!check(array)) {
        return null;
    }
    for (int value : array) {
        queue.add(new BinaryTreeImpl(value));
    }
    BinaryTreeImpl root = PreOrder(queue);
    return root;
}

private BinaryTreeImpl PreOrder(Queue<BinaryTreeImpl> queue) {
    if (queue == null) {
        return null;
    }
    BinaryTreeImpl root = queue.poll();
    if (root.value == Symbol) {
        return null;
    }
    root.left = PreOrder(queue);
    root.right = PreOrder(queue);
    return root;
}
  • 注意事项

将按中序遍历的方式输入的数组 构造成一个二叉树

  • 注意事项
    • 中序无法还原二叉树，因为无法找到跟节点

将按后序遍历的方式输入的数组 构造成一个二叉树

  • 设计思路
    • 通过队列记录数组顺序
    • 因为队列的最后一位是跟节点，继续后续生成二叉树。
    • 注意队列的入队顺序，因此先右孩子，再左孩子。
  • 主要代码
public BinaryTreeImpl createPostOrder(int[] array) {
    if (!check(array)) {
        return null;
    }
    Deque<BinaryTreeImpl> queue = new LinkedList<>();
    for (int value : array) {
        queue.add(new BinaryTreeImpl(value));
    }
    BinaryTreeImpl root = PostOrder(queue);
    return root;
}

private BinaryTreeImpl PostOrder(Deque<BinaryTreeImpl> queue) {
    if (queue == null) {
        return null;
    }
    BinaryTreeImpl root = queue.pollLast();
    if (root.value == Symbol) {
        return null;
    }
    root.right = PostOrder(queue);
    root.left = PostOrder(queue);
    return root;
}
  • 注意事项

将按照完全二叉树输入的数组 构造成一个完全二叉树

  • 设计思路
    • 第一步：判断此数组是否为完全二叉树，即数组长度是否为 2的n次方-1
    • 第二步：循环构建节点
    • 第三部：构建节点关系f(i)=f(2*i+1)
  • 主要代码
public BinaryTreeImpl createfulltree(int[] array) {
    if (array == null || array.length == 0) {
        return null;
    }
    int length = array.length;
    int base = 2;
    //判断一个数是否为 2的n次方-1
    int indexlength = String.valueOf(Math.log(length + 1) / Math.log(base)).length();
    //double型 整数 数字转字符串长度，长度为3
    if (indexlength > 3) {
        return null;
    }
    List<BinaryTreeImpl> btlist = new ArrayList<>();
    for (int i = 0; i < length; i++) {
        btlist.add(new BinaryTreeImpl(array[i]));
    }
    //注意此处的i < (length - 1) / 2，而不是i < (length + 1) / 2
    for (int i = 0; i < (length - 1) / 2; i++) {
        btlist.get(i).left = btlist.get(2 * i + 1);
        btlist.get(i).right = btlist.get(2 * i + 2);
    }
    return btlist.get(0);
}
  • 注意事项

根据前序遍历序列和中序遍历序列，构建唯一一棵确定的二叉树

  • 设计思路
    • 先序遍历的第一个节点是中序遍历的中间节点
    • 通过循环判断中间节点，将中序分成两部分，进行递归
  • 主要代码
public BinaryTreeImpl createTreePre_InOrder(int[] PreOrderarray, int preStart, int preEnd, int[] InOrderarray, int inStart, int inEnd) {
    if (preStart <= preEnd) {
        //此处是PreOrderarray[preStart]，不是PreOrderarray[0]
        int value = PreOrderarray[preStart];
        BinaryTreeImpl node = new BinaryTreeImpl(value);
        int index = 0;
        //循环不是从0 到 InOrderarray.length
        for (int i = inStart; i <= inEnd; i++) {
            if (value == InOrderarray[i]) {
                index = i;
                break;
            }
        }
        //此处length = index - inStart，而不是length = index - preStart
        int length = index - inStart;
        node.left = createTreePre_InOrder(PreOrderarray, preStart + 1, preStart + length,
                InOrderarray, inStart, index - 1);
        node.right = createTreePre_InOrder(PreOrderarray, preStart + length + 1, preEnd,
                InOrderarray, index + 1, inEnd);
        return node;
    }
    return null;
}
  • 注意事项

根据后序遍历序列和中序遍历序列，构建唯一一棵确定的二叉树

  • 设计思路
    • 后序遍历的最后一个节点是中序遍历的中间节点
    • 通过循环判断中间节点，将中序分成两部分，进行递归
  • 主要代码
public BinaryTreeImpl createTreePost_InOrder(int[] PostOrderarray, int postStart, int postEnd, int[] InOrderarray, int inStart, int inEnd) {
        if (postStart <= postEnd) {
            //此处是PreOrderarray[preStart]，不是PreOrderarray[0]
            int value = PostOrderarray[postEnd];
            BinaryTreeImpl node = new BinaryTreeImpl(value);
            int index = 0;
            //循环不是从0 到 InOrderarray.length
            for (int i = inStart; i <= inEnd; i++) {
                if (value == InOrderarray[i]) {
                    index = i;
                    break;
                }
            }
            //此处length = index - inStart，而不是length = index - preStart
            int length = index - inStart;
            node.left = createTreePost_InOrder(PostOrderarray, postStart, postStart + length - 1,
                    InOrderarray, inStart, index - 1);
            node.right = createTreePost_InOrder(PostOrderarray, postStart + length, postEnd - 1,
                    InOrderarray, index + 1, inEnd);
            return node;
        }
        return null;
    }
  • 注意事项

二叉树转链表

右孩子转左孩子的左孩子

  • 设计思路
    • 取出节点的左右孩子，右孩子置空
    • 循环左孩子（之前的）至叶子节点，
    • 将右孩子（之前的）复制给该叶子节点的左孩子
  • 主要代码
//将右孩子并至左孩子叶子结点，形成链表
private BinaryTreeImpl BinaryTree2LinkedList_Left(BinaryTreeImpl binaryTree) {
    if (binaryTree == null) {
        return null;
    }
    /**
     * 取出节点的左右孩子，右孩子置空
     * 循环左孩子（之前的）至叶子节点，
     * 将右孩子（之前的）复制给该叶子节点的左孩子
     */
    BinaryTree2LinkedList_Left(binaryTree.left);
    BinaryTree2LinkedList_Left(binaryTree.right);
    BinaryTreeImpl nodeleft = binaryTree.left;
    BinaryTreeImpl noderight = binaryTree.right;
    binaryTree.right = null;
    BinaryTreeImpl p = binaryTree;
    //注意此处的写法是p.left 而不是p，因为存在判空问题
    while (p.left != null) {
        p = p.left;
    }
    p.left = noderight;
    return binaryTree;
}
  • 注意事项

左孩子转右孩子的右孩子

  • 设计思路
    • 取出节点的左右孩子，直接把左孩子复制给跟节点的右孩子，左孩子置空
    • 循环右孩子（之前的左孩子）至叶子节点，
    • 将右孩子（之前的）复制给该叶子节点的右孩子
  • 主要代码
private BinaryTreeImpl BinaryTree2LinkedList_Right(BinaryTreeImpl binaryTree) {
    if (binaryTree == null) {
        return null;
    }
    /**
     * 取出节点的左右孩子，直接把左孩子复制给跟节点的右孩子，左孩子置空
     * 循环右孩子（之前的左孩子）至叶子节点，
     * 将右孩子（之前的）复制给该叶子节点的右孩子
     */
    BinaryTree2LinkedList_Right(binaryTree.left);
    BinaryTree2LinkedList_Right(binaryTree.right);
    BinaryTreeImpl nodeleft = binaryTree.left;
    BinaryTreeImpl noderight = binaryTree.right;
    binaryTree.left = null;
    binaryTree.right = nodeleft;
    BinaryTreeImpl p = binaryTree;
    //注意此处的写法是p.left 而不是p，因为存在判空问题
    while (p.right != null) {
        p = p.right;
    }
    p.right = noderight;
    return binaryTree;
}
  • 注意事项
New俊
关注
  • 2
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
【leetcode-树】二叉树的序列化与反序列化
12-21
序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。 请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。 示例:  你可以将以下二叉树： 1 / \ 2 3 / \ 4 5 序列化为 "[1,2,3,null,null,4,5]" 提示: 这与 LeetCode 目前使用的方式一致，详情请参阅 Leet
lintcode7. 二叉树的序列化和反序列化
01-06
设计一个算法，并编写代码来序列化和反序列化二叉树。将树写入一个文件被称为“序列化”，读取文件后重建同样的二叉树被称为“反序列化”。 如何反序列化或序列化二叉树是没有限制的，你只需要确保可以将二叉树序列...
序列化/反序列化二叉树
热门推荐
__七把刀__
07-24 1万+
题目 设计一个算法能够实现序列化和反序列化一棵二叉树（注意，不是二叉搜索树BST）。这里的序列化指的是将一棵二叉树保存到文件中，反序列化就是从文件中读取二叉树结点值重构原来的二叉树。 思路 前一篇文章保存二叉搜索树到文件中  解决了保存一棵二叉搜索树到文件中的问题，但是由于本题目的意思是要把一棵二叉树保存到文件中并从文件中读出重构二叉树。因为二叉树不一定是二叉搜索树，所以前面文章中的
数据结构：二叉树的序列化和反序列化（序列和二叉树结构一一对应）
最新发布
m0_63997099的博客
05-16 1551
序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。
二叉树的序列化和反序列化
coffee_dount的博客
05-08 334
二叉数序列化 二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过某种符号表示空节点（#），以 _ 表示一个结点值的结束（value_）。 下图是先序序列化的示意图： 二叉树的反序列化 二叉树的反序列化是指：根据某种遍历顺序得...
二叉树的序列化与反序列化
明朗晨光的专栏
06-20 1969
二叉树的序列化与反序列化
Python实现的序列化和反序列化二叉树算法示例
09-19
总的来说，通过Python实现的二叉树序列化和反序列化算法，可以高效地将二叉树结构转换为字符串，并能从字符串恢复原来的二叉树结构。这对于数据存储、网络通信以及在代码中持久化二叉树状态都具有重要意义。
Python 序列化二叉树
01-21
实现两个函数，分别用来序列化和反序列化二叉树 #-*- coding:utf-8 -*- class TreeNode: def __init__(self,x): self.val = x self.left=None self.right =None class Solution: def Serialize(self,root): ...
二叉树的（反）序列化
miaochengshi的博客
10-26 475
Tree Serialization 树的序列化 问题描述 实现二叉树的序列化和反序列化： 序列化：将一个给定的二叉树用一个序列表示，空结点用 # 表示。 反序列化：给定一个序列化的二叉树，重建该二叉树。 测试样例 # Input: 1 / \ 3 4 / \ \ 2 5 7 # Output: 1 3 2 # # 5 # # 4 # 7 # # # Input: 1 3 2 # # 5 # # 4 # 7 # # # Output: 132547 #
二叉树 序列化与反序列化
一只老风铃
03-18 202
序列化（serialization）在计算机科学的数据处理中，是指将数据结构或对象状态转换成可取用格式（例如存成文件，存于缓冲，或经由网络中发送），以留待后续在相同或另一台计算机环境中，能恢复原先状态的过程。从一系列字节提取数据结构的反向操作，是反序列化（也称为解编组、deserialization、unmarshalling）。 实现二叉树的序列化与反序列化 思路： 前序遍历过程中，每遇到...
二叉树的序列化和反序列化C语言
05-06
二叉树的序列化和反序列化是指将二叉树转化为字符串，或将字符串转化为二叉树的过程。在C语言中，可以使用递归的方式来实现二叉树的序列化和反序列化。 以下是二叉树序列化的实现方法： ```C void serialize(TreeNode* root, FILE* fp) { if (root == NULL) { fprintf(fp, "# "); return; } fprintf(fp, "%d ", root->val); serialize(root->left, fp); serialize(root->right, fp); } ``` 该方法中，我们首先判断当前节点是否为空，如果为空，则在字符串中加入一个特殊字符“#”，表示该节点为空。如果当前节点不为空，则将该节点的值加入字符串中，然后递归序列化左子树和右子树。 以下是二叉树反序列化的实现方法： ```C TreeNode* deserialize(FILE* fp) { char c; fscanf(fp, "%c", &c); if (c == '#') { return NULL; } int val; fscanf(fp, "%d", &val); TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode)); root->val = val; root->left = deserialize(fp); root->right = deserialize(fp); return root; } ``` 该方法中，我们首先从字符串中读取一个字符，如果该字符为特殊字符“#”，则返回空节点。如果该字符为数字，则读取该数字，并创建一个新节点。然后递归创建左子树和右子树，并将其赋值给新节点。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值