算法---LeetCode 297. 二叉树的序列化与反序列化(剑指offer 37)

1. 题目

原题链接

序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方
式重构得到原数据。
请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串
反序列化为原始的树结构。
示例:
你可以将以下二叉树：
1
/
2 3
/
4 5
序列化为 “[1,2,3,null,null,4,5]”
提示: 这与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这
个问题。
说明: 不要使用类的成员 / 全局 / 静态变量来存储状态，你的序列化和反序列化算法应该是无状态的。
Related Topics 树 设计
👍 446 👎 0

2. 题解

2.1 解法1: DFS 前序遍历

    public class Codec {
        // Encodes a tree to a single string.
        public String serialize(TreeNode root) {
            if (root == null) return "null,";
            String str = root.val + ",";
            String left = serialize(root.left);
            String right = serialize(root.right);
            return str + left + right;
        }
        // Decodes your encoded data to tree.
        public TreeNode deserialize(String data) {
            String[] ss = data.split(",");
            Queue<String> queue = new LinkedList<>(Arrays.asList(ss));//注意用  queue转化
            return dfsDe(queue);
        }

        public TreeNode dfsDe(Queue<String> queue) {
            if (queue.isEmpty()) return null;// 由于最后一个值肯定是null, 所以也可以不用判断 list为空的情况
            String str = queue.poll();
            if (str.equals("null")) return null;
            TreeNode root = new TreeNode(Integer.parseInt(str));
            root.left = dfsDe(queue);
            root.right = dfsDe(queue);
            return root;
        }
    }

2.2 解法2: BFS 层序遍历

    public class Codec {

        // Encodes a tree to a single string.
        public String serialize(TreeNode root) {
            if (root == null) {
                return "";
            }
            Queue<TreeNode> queue = new LinkedList<>();
            queue.add(root);
            StringBuilder strB = new StringBuilder();
            while (!queue.isEmpty()) {
                TreeNode temp = queue.poll();
                if (temp == null) {
                    strB.append("null,");
                } else {
                    strB.append(temp.val).append(",");
                    queue.add(temp.left);
                    queue.add(temp.right);
                }
            }
            return strB.toString();
        }


        // Decodes your encoded data to tree.
        public TreeNode deserialize(String data) {
            if (data.equals("")) {
                return null;
            }
            // 先将字符串转化为 List
            String[] dataArray = data.split(",");
            Queue<String> strQue = new LinkedList<>(Arrays.asList(dataArray));
            Queue<TreeNode> treeQue = new LinkedList<>();
            // 创建第一个根节点
            TreeNode root = new TreeNode(Integer.parseInt(strQue.poll()));
            treeQue.add(root);
            // 注意判断条件一定是对树节点的队列
            while (!treeQue.isEmpty()) {
                TreeNode temp = treeQue.poll();
                String left = strQue.poll();
                String right = strQue.poll();
                if (!left.equals("null")) {
                    temp.left = new TreeNode(Integer.parseInt(left));
                    treeQue.add(temp.left);
                }
                if (!right.equals("null")) {
                    temp.right = new TreeNode(Integer.parseInt(right));
                    treeQue.add(temp.right);
                }
            }
            return root;
        }


    }

参考:
『手画图解』剖析DFS、BFS解法 | 二叉树的序列化与反序列化