【基础算法】二叉树的按层遍历序列化与反序列化

package test;

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

public class SeriaByLevel {
    //  按层遍历二叉树的方式序列化
    public static String binToStr(Node head) {
        StringBuilder stringBuilder = new StringBuilder();
        Queue<Node> queue = new LinkedList<>();
        Node nNode = null;
        queue.offer(head);
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            if (node != null) {
                stringBuilder.append(node.val+"!");
            }
            else {
                stringBuilder.append("#!");
                continue;
            }
            if (node.left != null) {
                queue.offer(node.left);
            }
            else {
                queue.offer(nNode);
            }
            if (node.right != null){
                queue.offer(node.right);
            }
            else {
                queue.offer(nNode);
            }
        }
        return stringBuilder.toString();
    }
    //    按层遍历二叉树的方式反序列化
    public static Node strToQueCeng(String string) {
        Queue<Node> queue = new LinkedList<>();
        String values[] = string.split("!");
        int index = 0;
        Node head = new Node(Integer.valueOf(values[index++]));
        queue.offer(head);
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            node.left = getNewNode(values[index ++]);
            node.right = getNewNode(values[index ++]);
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
        return head;
    }

    public static Node getNewNode(String val) {
        if (val.equals("#")) {
            return null;
        }
        else {
            return new Node(Integer.valueOf(val));
        }
    }
// 按层遍历二叉树
    public static void nodePrint (Node head) {
        Node last = head;
        Node nlast = head;
        Queue<Node> queue = new LinkedList<>();
        queue.offer(head);
        while (!queue.isEmpty()) {
            Node 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 (last == node) {
                System.out.println();
                last = nlast;
            }
        }
    }

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

        n1.left = n2;
        n1.right = n3;
        n2.left = n4;
        n3.left = n5;
        n3.right = n6;
        n5.left = n7;
        n5.right = n8;
//测试序列化
        String string = binToStr(n1);
        System.out.println(string);
// 测试反序列化
        Node head = strToQueCeng(string);
        nodePrint(head);
    }
}
class Node {
    Node left;
    Node right;
    int val;
    public Node () {}
    public Node (int val) {
        this.val = val;
    }
}