标签：node return String builder 二叉树 new TreeNode 序列化

1. 二叉树的序列化、反序列化

1.1. 问题

将一个二叉树序列化为字符串。

从序列化后的字符串重建一棵二叉树。

1.2. 思路

用#表示空节点，用!表示一个节点的结尾。

这道题可以用二叉树的前序遍历、后序遍历、层序遍历来做。

中序遍历不好做，因为给定一个序列后，没办法一下子将根节点找出来。

对于前序、后序遍历，可以考虑递归和使用栈的方法来弄，使用morris遍历不好做。因为序列化后的字符串需要包含空节点的信息，而morris遍历，不好来拿空节点的信息。

1.3. 代码

1.3.1. 前序法

    public static String serializeByPre(TreeNode<Integer> root) {
        StringBuilder builder = new StringBuilder();
        buildPreStr(root, builder);
        return builder.toString();
    }

    private static void buildPreStr(TreeNode<Integer> node, StringBuilder builder) {
        if (node == null) {
            builder.append("#!");
            return;
        }

        builder.append(node.val).append("!");
        buildPreStr(node.left, builder);
        buildPreStr(node.right, builder);
    }

    public static TreeNode<Integer> deserializeByPre(String str) {
        String[] strs = str.split("!");
        Queue<String> queue = new LinkedList<>(Arrays.asList(strs));
        return buildTreeByPre(queue);
    }

    private static TreeNode<Integer> buildTreeByPre(Queue<String> queue) {
        String str = queue.remove();
        if ("#".equals(str)) {
            return null;
        }
        TreeNode<Integer> node = new TreeNode<>(Integer.valueOf(str));
        node.left = buildTreeByPre(queue);
        node.right = buildTreeByPre(queue);
        return node;
    }

1.3.2. 后序法

    public static String serializeByPost(TreeNode<Integer> root) {
        if (root == null) {
            return "#!";
        }
        StringBuilder builder = new StringBuilder();
        buildPostStr(root, builder);
        return builder.toString();
    }

    private static void buildPostStr(TreeNode<Integer> head, StringBuilder builder) {
        if (head == null) {
            builder.append("#!");
            return;
        }
        buildPostStr(head.left, builder);
        buildPostStr(head.right, builder);
        builder.append(head.val);
        builder.append('!');
    }

    public static TreeNode<Integer> deserializeByPost(String postStr) {
        String[] nodes = postStr.split("!");
        Stack<String> stack = new Stack<>();
        for (String s :nodes) {
            stack.push(s);
        }
        return buildTreeByPost(stack);
    }

    public static TreeNode<Integer> buildTreeByPost(Stack<String> stack) {
        String s = stack.pop();
        if(s.equals("#")) {
            return null;
        }
        TreeNode<Integer> head = new TreeNode<>(Integer.valueOf(s));
        head.right = buildTreeByPost(stack);
        head.left = buildTreeByPost(stack);
        return head;
    }

1.3.3. 层序法

    public static String serializeByLevel(TreeNode<Integer> root) {
        if (root == null) {
            return "#!";
        }

        StringBuilder builder = new StringBuilder();
        Queue<TreeNode<Integer>> queue = new LinkedList<>();
        queue.add(root);
        TreeNode<Integer> nil = new TreeNode<>();
        while (!queue.isEmpty()) {
            TreeNode<Integer> node = queue.remove();
            if (node == nil) {
                builder.append("#");
            } else {
                builder.append(node.val);
                queue.add(node.left == null ? nil : node.left);
                queue.add(node.right == null ? nil : node.right);
            }
            builder.append("!");
        }
        return builder.toString();
    }

    public static TreeNode<Integer> deserializeByLevel(String data) {
        if (data == null || data.isEmpty() || "#!".equals(data)) {
            return null;
        }

        Queue<String> children = new LinkedList<>(Arrays.asList(data.split("!")));
        Queue<TreeNode<Integer>> parents = new LinkedList<>();

        TreeNode<Integer> root = new TreeNode<>(Integer.valueOf(children.remove()))
        parents.add(root);
        while (!parents.isEmpty()) {
            TreeNode<Integer> node = parents.remove();
            String leftVal = children.remove();
            String rightVal = children.remove();

            if ("#".equals(leftVal)) {
                node.left = null;
            } else {
                TreeNode<Integer> left = new TreeNode<>(Integer.valueOf(leftVal));
                node.left = left;
                parents.add(left);
            }

            if ("#".equals(rightVal)) {
                node.right = null;
            } else {
                TreeNode<Integer> right = new TreeNode<>(Integer.valueOf(rightVal));
                node.right = right;
                parents.add(right);
            }
        }
        return root;
    }

标签：node,return,String,builder,二叉树,new,TreeNode,序列化
来源： https://www.cnblogs.com/stepfortune/p/16259242.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。