JAVA学习-练习试用Java实现“二叉树的序列化与反序列化”

问题：

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

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

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

示例 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]
提示：

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

解答思路：

以下是使用 Java 实现二叉树的序列化与反序列化的代码：

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

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

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

public class SerializeAndDeserializeBinaryTree {
    // 序列化二叉树
    public String serialize(TreeNode root) {
        if (root == null) {
            return "[]";
        }

        StringBuilder sb = new StringBuilder();
        sb.append('[');

        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();

            if (node!= null) {
                sb.append(node.val).append(',');
                queue.add(node.left);
                queue.add(node.right);
            } else {
                sb.append("null,");
            }
        }

        sb.deleteCharAt(sb.length() - 1);
        sb.append(']');

        return sb.toString();
    }

    // 反序列化二叉树
    public TreeNode deserialize(String data) {
        if (data.equals("[]")) {
            return null;
        }

        String[] values = data.substring(1, data.length() - 1).split(",");
        Queue<TreeNode> queue = new LinkedList<>();

        TreeNode root = new TreeNode(Integer.parseInt(values[0]));
        queue.add(root);

        int i = 1;
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();

            if (!values[i].equals("null")) {
                node.left = new TreeNode(Integer.parseInt(values[i]));
                queue.add(node.left);
            }
            i++;

            if (!values[i].equals("null")) {
                node.right = new TreeNode(Integer.parseInt(values[i]));
                queue.add(node.right);
            }
            i++;
        }

        return root;
    }

    public static void main(String[] args) {
        // 构建二叉树
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.right.left = new TreeNode(4);
        root.right.right = new TreeNode(5);

        SerializeAndDeserializeBinaryTree serializer = new SerializeAndDeserializeBinaryTree();
        String serializedTree = serializer.serialize(root);
        System.out.println("序列化后的二叉树: " + serializedTree);

        TreeNode deserializedTree = serializer.deserialize(serializedTree);
        System.out.println("反序列化后的二叉树:");
        // 打印反序列化后的二叉树
        printTree(deserializedTree);
    }

    // 打印二叉树
    public static void printTree(TreeNode root) {
        if (root == null) {
            return;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        while (!queue.isEmpty()) {
            int size = queue.size();

            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                System.out.print(node.val + " ");

                if (node.left!= null) {
                    queue.add(node.left);
                }
                if (node.right!= null) {
                    queue.add(node.right);
                }
            }

            System.out.println();
        }
    }
}

这段代码实现了二叉树的序列化与反序列化。序列化过程中，使用广度优先搜索遍历二叉树，将每个节点的值添加到字符串中，并用逗号分隔。如果节点为空，则添加 'null'。反序列化过程中，将字符串按照逗号分割成数组，然后使用队列依次构建二叉树的节点。在 'main' 方法中，构建了一个示例二叉树，并进行序列化和反序列化操作，最后打印出序列化后的字符串和反序列化后的二叉树。

(文章为作者在学习java过程中的一些个人体会总结和借鉴，如有不当、错误的地方，请各位大佬批评指正，定当努力改正，如有侵权请联系作者删帖。)