61. 序列化二叉树

文章目录

• 题目描述
• 1. 层序遍历
• 代码实现
• 复杂度分析
• 2. 先序遍历
• 代码实现
• 复杂度分析

题目描述

请实现两个函数，分别用来序列化和反序列化二叉树
二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。
二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

1. 层序遍历

代码实现

/**
 * @Classname Solution
 * @Description 基于层序遍历
 * @Date 2019/12/29 8:31
 * @Author SonnSei
 */
public class Solution {
    public static String Serialize(TreeNode root) {
        if(root == null) return "#!";
        StringBuilder ret = new StringBuilder();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            if (cur == null) {
                ret.append("#!");
            } else {
                ret.append(cur.val + "!");
                queue.add(cur.left);
                queue.add(cur.right);
            }
        }
        return ret.toString();
    }
    public static TreeNode Deserialize(String str) {
        String[] values = str.split("!");
        if(values[0].equals("#"))return null;
        Queue<TreeNode> queue = new LinkedList<>();
        TreeNode root = new TreeNode(Integer.parseInt(values[0]));
        queue.add(root);
        for (int i = 1; i < values.length; i+=2) {
            TreeNode cur = queue.poll();
            String leftV = values[i];
            String rightV = values[i+1];
            if (!leftV.equals("#")) {
                TreeNode left = new TreeNode(Integer.parseInt(leftV));
                cur.left = left;
                queue.add(left);
            }
            if (!rightV.equals("#")) {
                TreeNode right = new TreeNode(Integer.parseInt(rightV));
                cur.right = right;
                queue.add(right);
            }
        }
        return root;
    }
}

复杂度分析

• 序列化：都是${O(n)}$
• 反序列化：都是${O(n)}$

2. 先序遍历

代码实现

/**
 * @Classname Solution
 * @Description 基于前序遍历
 * @Date 2019/12/29 9:11
 * @Author SonnSei
 */
public class Solution {
    public static String Serialize(TreeNode root) {
        StringBuilder ret = new StringBuilder();
        preOrder(root, ret);
        return ret.toString();
    }

    private static void preOrder(TreeNode node, StringBuilder ret) {
        if (node == null) {
            ret.append("#!");
            return;
        } else {
            ret.append(node.val + "!");
        }
        preOrder(node.left,ret);
        preOrder(node.right,ret);
    }

    public static TreeNode Deserialize(String str) {
        String[] values = str.split("!");
        Queue<String> queue = new LinkedList<>();
        for (String item : values) {
            queue.add(item);
        }
        return deserialize(queue);
    }

    private static TreeNode deserialize(Queue<String> queue) {
        String value = queue.poll();
        if (value.equals("#")) {
            return null;
        }
        TreeNode root= new TreeNode(Integer.parseInt(value));
        root.left = deserialize(queue);
        root.right = deserialize(queue);
        return root;
    }
}

复杂度分析

• 序列化：都是${O(n)}$
• 反序列化：都是${O(n)}$

来源：CSDN

作者：SonnSei

链接：https://blog.csdn.net/weixin_40602200/article/details/103751257