【基础算法】二叉树的先序序列化与反序列化

二叉树序列化：

1，假设序列化结果为str，初始时str为空

2，先序遍历遇到空节点，在str末尾加上#！

3，如果遇到不为空的节点，假设节点为3，在str末尾加上3！

二叉树反序列化：

1，以！为分隔符

2，按先序遍历组成二叉树

package test;

import java.util.LinkedList;
import java.util.Queue;

public class Serialization {
    private static class BinaryNode{
        int val;
        BinaryNode left;
        BinaryNode right;

        public BinaryNode(){}
        public BinaryNode(int val){
            this.val = val;
        }
    }
//    先序方式序列化
    public static String binaryToString(BinaryNode head){
        StringBuilder stringBuilder = new StringBuilder();
        if(head == null){
            stringBuilder.append("#!");
            return  stringBuilder.toString();
        }
        stringBuilder.append(head.val+"!");
        stringBuilder.append(binaryToString(head.left));
        stringBuilder.append(binaryToString(head.right));
        return stringBuilder.toString();
    }
//    反序列化
    public static Queue strToQueue(String str){
        String[] strArr = str.split("!");
        Queue<String> queue = new LinkedList<>();
        for (int i = 0; i < strArr.length; i++) {
            queue.offer(strArr[i]);
        }
        return queue;
    }
    public static BinaryNode QueueToBin(Queue<String> queue){
        String val = queue.poll();
        if (val.equals("#")) {
            return null;
        }
        BinaryNode head = new BinaryNode(Integer.valueOf(val));
        head.left = QueueToBin(queue);
        head.right = QueueToBin(queue);
        return head;
    }
//    按层遍历二叉树
    public static void binaryPrint(BinaryNode head){
       Queue<BinaryNode> queue = new LinkedList<>();
       queue.offer(head);
       BinaryNode nlast = head;
       BinaryNode last = head;

       while (!queue.isEmpty()) {
           BinaryNode node = queue.poll();
           System.out.print(node.val);
           System.out.print("\t");
           if (node.left != null){
               queue.offer(node.left);
               nlast = node.left;
           }
           if (node.right != null){
               queue.offer(node.right);
               nlast = node.right;
           }
           if (node == last){
               System.out.println();
               last = nlast;
           }
       }

    }
//    测试
    public static void main(String[] args){
        BinaryNode n1 = new BinaryNode(1);
        BinaryNode n2 = new BinaryNode(2);
        BinaryNode n3 = new BinaryNode(3);
        BinaryNode n4 = new BinaryNode(4);
        BinaryNode n5 = new BinaryNode(5);
        BinaryNode n6 = new BinaryNode(6);
        BinaryNode n7 = new BinaryNode(7);
        BinaryNode n8 = new BinaryNode(8);

        n1.left = n2;
        n1.right = n3;
        n2.left = n4;
        n3.left = n5;
        n3.right = n6;
        n5.left = n7;
        n5.right = n8;
//        序列化
        String serializationStr = binaryToString(n1);
        System.out.println(serializationStr);
//        反序列化
        Queue queue = strToQueue(serializationStr);
        BinaryNode head = QueueToBin(queue);
        binaryPrint(head);
    }
}

按层遍历的方式对二叉树进行序列化