【LeetCode】【HOT】297. 二叉树的序列化与反序列化（BFS）-CSDN博客

本文链接：https://blog.csdn.net/qq_45593575/article/details/122672321

本文介绍了一种二叉树的序列化与反序列化方法，使用队列实现广度优先遍历，支持将二叉树结构转换为字符串形式，并能从该字符串还原出原来的二叉树结构。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

【LeetCode】【HOT】297. 二叉树的序列化与反序列化

文章目录

【LeetCode】【HOT】297. 二叉树的序列化与反序列化

在这里插入图片描述

package hot;

import java.util.LinkedList;
import java.util.Queue;

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

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

public class Solution297 {
    public static void main(String[] args) {
        TreeNode node1 = new TreeNode(1);
        TreeNode node2 = new TreeNode(2);
        TreeNode node3 = new TreeNode(3);
        TreeNode node4 = new TreeNode(4);
        TreeNode node5 = new TreeNode(5);
        node1.left = node2;
        node1.right = node3;
        node3.left = node4;
        node3.right = node5;
        Solution297 solution = new Solution297();
        System.out.println(solution.serialize(node1));
        TreeNode root = solution.deserialize(solution.serialize(node1));
        System.out.println(root.val);
        System.out.println(root.left.val);
        System.out.println(root.right.val);
        System.out.println(root.right.left.val);
        System.out.println(root.right.right.val);
    }

    private String serialize(TreeNode root){
        if(root == null) return "[]";
        StringBuilder res = new StringBuilder();
        Queue<TreeNode> queue = new LinkedList<>();
        res.append("[");
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
            if(node != null){
                res.append(node.val+",");
                queue.add(node.left);
                queue.add(node.right);
            }else{
                res.append("null,");
            }
        }
        res.deleteCharAt(res.length() - 1);
        res.append("]");
        return res.toString();

    }
    //时间复杂度为 O(n)
    //空间复杂度为 O(n)

    private TreeNode deserialize(String data){
        if(data.equals("[]")) return null;
        String[] vals = data.substring(1, data.length() - 1).split(",");
        TreeNode root = new TreeNode(Integer.parseInt(vals[0]));
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int i = 1;
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
            if(!vals[i].equals("null")){
                node.left = new TreeNode(Integer.parseInt(vals[i]));
                queue.add(node.left);
            }
            i++;
            if (!vals[i].equals("null")){
                node.right = new TreeNode(Integer.parseInt(vals[i]));
                queue.add(node.right);
            }
            i++;
        }
        return root;
    }
    //时间复杂度为 O(n)
    //空间复杂度为 O(n)
}