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

• 二叉树只能通过先序和后序或者层序进行序列化和反序列化
• 中序不可以进行序列化和反序列化
• 比如如下两棵树
• __2
• /
• 1
• 和
• 1 __
• \
• 2
• 补足空位置的中序遍历结果都是{ null, 1, null, 2, null}

一、先序

序列化

  public static Queue<String> preSerial(Node head) {
        Queue<String> ans = new LinkedList<>();
        pres(head, ans);
        return ans;
    }

    /**
     * 先序遍历序列化
     *
     * @param head
     * @param ans
     */
    public static void pres(Node head, Queue<String> ans) {
        if (head == null) {
            ans.add(null);
        } else {
            ans.add(String.valueOf(head.value));
            pres(head.left, ans);
            pres(head.right, ans);
        }
    }

反序列化

 public static Node buildByPreQueue(Queue<String> preList) {
        if (preList == null || preList.size() == 0) {
            return null;
        }
        return preb(preList);
    }

    /**
     * 先序遍历反序列化二叉树
     *
     * @param preList
     * @return
     */
    private static Node preb(Queue<String> preList) {
        String value = preList.poll();
        if (value == null) {
            return null;
        }
        Node head = new Node(Integer.valueOf(value));
        head.left = preb(preList);
        head.right = preb(preList);
        return head;
    }

二、中序

序列化

    public static Queue<String> inSerial(Node head) {
        Queue<String> ans = new LinkedList<>();
        inSerialBuild(head, ans);
        return ans;
    }

    /**
     * 中序序列化二叉树
     *
     * @param head
     * @param ans
     */
    private static void inSerialBuild(Node head, Queue<String> ans) {
        if (head == null) {
            ans.add(null);
        } else {
            inSerialBuild(head.left, ans);
            ans.add(String.valueOf(head.value));
            inSerialBuild(head.right, ans);
        }
    }

反序列化 ， 中序不可反序列化

三、后序

序列化

 public static Queue<String> posSerial(Node head) {
        Queue<String> ans = new LinkedList<>();
        posSerialBuild(head, ans);
        return ans;
    }

    /**
     * 后序序列化二叉树
     *
     * @param head
     * @param ans
     */
    private static void posSerialBuild(Node head, Queue<String> ans) {
        if (head == null) {
            ans.add(null);
        } else {
            posSerialBuild(head.left, ans);
            posSerialBuild(head.right, ans);
            ans.add(String.valueOf(head.value));
        }
    }

反序列化

 /**
     * 后序 反序列化出二叉树
     *
     * @param posList
     * @return
     */
    public static Node buildByPosQueue(Queue<String> posList) {
        if (posList == null || posList.size() == 0) {
            return null;
        }
        Stack<String> stack = new Stack<>();
        //左右中 ——> 中右左
        while (!posList.isEmpty()) {
            stack.push(posList.poll());
        }
        return posb(stack);
    }

    private static Node posb(Stack<String> stack) {
        String value = stack.pop();
        if (value == null) {
            return null;
        }
        Node head = new Node(Integer.valueOf(value));
        head.right = posb(stack);
        head.left = posb(stack);
        return head;
    }

四、层序

序列化

  /**
     * 层序 序列化二叉树
     *
     * @param head
     * @return
     */
    public static Queue<String> levelSerial(Node head) {
        Queue<String> ans = new LinkedList<>();
        if (head == null) {
            ans.add(null);
        } else {
            ans.add(String.valueOf(head));
            Queue<Node> queue = new LinkedList<>();
            queue.add(head);
            while (!queue.isEmpty()) {
                //层序遍历，有值就添加，无值就添加null
                head = queue.poll();
                ans.add(String.valueOf(head));
                if (head.left != null) {
                    ans.add(String.valueOf(head.left.value));
                    queue.add(head.left);
                } else {
                    ans.add(null);
                }
                if (head.right != null) {
                    ans.add(String.valueOf(head.right.value));
                    queue.add(head.right);
                } else {
                    ans.add(null);
                }
            }
        }
        return ans;
    }

反序列化

 /**
     * 层序 反序列化 二叉树
     *
     * @param levelQueue
     * @return
     */
    public static Node buildByLevelQueue(Queue<String> levelQueue) {
        if (levelQueue == null || levelQueue.size() == 0) {
            return null;
        }
        Node head = generateNode(levelQueue.poll());
        Queue<Node> queue = new LinkedList<>();
        queue.add(head);
        while (!queue.isEmpty()) {
            head = queue.poll();
            head.left = generateNode(levelQueue.poll());
            head.right = generateNode(levelQueue.poll());
            //可能左右为null
            if (head.left != null) {
                queue.add(head.left);
            }
            if (head.right != null) {
                queue.add(head.right);
            }
        }
        return head;
    }

    private static Node generateNode(String node) {
        if (node == null) {
            return null;
        } else {
            return new Node(Integer.valueOf(node));
        }

    }