Leetcode NO.297 Serialize And Deserialize Binary Tree

目录

• 1.问题描述
• 2.测试用例
  • • 示例 1
    • 示例2
    • 示例3
    • 示例4
• 3.提示
• 4.代码
  • • 1.DFS序列化 二叉树
      • code
      • 复杂度

1.问题描述

序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。

请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

提示: 输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。

2.测试用例

示例 1

输入：root = [1,2,3,null,null,4,5]
输出：[1,2,3,null,null,4,5]

示例2

输入：root = []
输出：[]

示例3

输入：root = [1]
输出：[1]

示例4

输入：root = [1,2]
输出：[1,2]

3.提示

• 树中结点数在范围 [0, 104] 内 -1000 <= Node.val <= 1000

4.代码

1.DFS序列化 二叉树

code

public class Top297_Serialize_And_Deserialize_Binary_Tree {
    public String serialize(TreeNode root) {
        StringBuffer res = new StringBuffer();
        res.append("[");
        dfsSerialize(root, res);
        res.deleteCharAt(res.length() - 1);
        res.append("]");
        return res.toString();
    }
    private void dfsSerialize(TreeNode root, StringBuffer res) {
        if (root == null) {
            res.append("null,");
            return;
        }
        res.append(root.val).append(",");
        dfsSerialize(root.left, res);
        dfsSerialize(root.right, res);
    }

    public TreeNode deserialize(String data) {
        String[] split = data.split(",");
        LinkedList<String> led = new LinkedList<>(Arrays.asList(split));
        String first = led.getFirst();
        String firstEle = first.split("\\[")[1];
        led.removeFirst();
        led.addFirst(firstEle);

        String lastEle = led.getLast().substring(0, led.getLast().length() - 1);
        led.removeLast();
        led.addLast(lastEle);

        return dfsDeserialize(led);
    }

    private TreeNode dfsDeserialize(LinkedList<String> led) {
        String first = led.peek();
        if ("null".equals(first) || first == null || "".equals(first)) {
            led.poll();
            return null;
        }

        TreeNode node = new TreeNode(Integer.parseInt(first));
        led.poll();
        node.left = dfsDeserialize(led);
        node.right = dfsDeserialize(led);
        return node;
    }
}


public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;


    public TreeNode() {

    }

    public TreeNode(int val) {
        this.val = val;
    }

    public TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

复杂度

* 时间复杂度 O（n）
* 空间复杂度 O（n）