《程序员代码面试指南》二叉树的序列化和反序列化——java实现

二叉树的序列化和反序列化

题目描述：

二叉树被记录成文件的过程叫作二叉树的序列化，通过文件内容重建原来二叉树的过程叫作二叉树的反序列化。
给定一棵二叉树的头节点head，并已知二叉树节点值的类型为32位整型。请设计一种二叉树序列化和反序列化的方案，并用代码实现。
【要求】
1，实现先序遍历序列化与反序列化
2，实现按层遍历序列化与反序列化

题目难度：

medium

题目思路：

1、先序遍历序列化，即采用递归的方式，如果遇到null，则拼接“#”，反之则拼接“”。
2、反序列化，先采用字符串分割，将每个字符串添加到队列中；采用递归的方式，分别找到头结点及左右孩子节点。

代码实现：

       public static class Node {
        public int value;
        public Node left;
        public Node right;

        public Node(int data) {
            this.value = data;
        }
    }

    //先序遍历序列化
    public static String serialByPre(Node head) {
        if (head == null) {
            return "#_";
        }
        String res = head.value + "_";
        res += serialByPre(head.left);
        res += serialByPre(head.right);
        return res;
    }

    //先序遍历反序列化
    public static Node reconByPreString(String preStr) {
        String[] vlaue = preStr.split("_");
        Queue<String> queue = new LinkedList<>();
        for (String str : vlaue) {
            queue.offer(str);
        }
        return reconPreOrder(queue);
    }

    private static Node reconPreOrder(Queue<String> queue) {
        String value = queue.poll();
        if (value.equals("#")) {
            return null;
        }
        Node head = new Node(Integer.valueOf(value));
        head.left = reconPreOrder(queue);
        head.right = reconPreOrder(queue);
        return head;
    }


    //按层遍历序列化
    public static String serialByLevel(Node head) {
        if (head == null) {
            return "#_";
        }
        String res = head.value + "_";
        Queue<Node> queue = new LinkedList<>();
        queue.offer(head);
        while (!queue.isEmpty()) {
            head = queue.poll();
            if (head.left != null) {
                queue.offer(head.left);
                res += head.left.value + "_";
            } else {
                res += "#_";
            }
            if (head.right != null) {
                queue.offer(head.right);
                res += head.right.value + "_";
            } else {
                res += "#_";
            }
        }
        return res;
    }

    //按层遍历反序列化
    public static Node reconByLevelString(String levelStr){
        if (levelStr == null || levelStr.length() == 0){
            return null;
        }
        String[] str = levelStr.split("_");
        int index = 0;
        Queue<Node> queue = new LinkedList<>();
        Node head= generateNodeByString(str[index++]);
        if (head == null){
            return null;
        }
        queue.offer(head);
        Node node = null;
        while (!queue.isEmpty()){
            node = queue.poll();
            node.left = generateNodeByString(str[index++]);
            node.right = generateNodeByString(str[index++]);
            if (node.left!=null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
        return head;
    }

    private static Node generateNodeByString(String s) {
        if (s.equals("#")){
            return null;
        }
        return new Node(Integer.valueOf(s));
    }