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

最新推荐文章于 2024-07-18 18:08:02 发布

huiyudaoyi

最新推荐文章于 2024-07-18 18:08:02 发布

阅读量721

点赞数

CC 4.0 BY-SA版权

分类专栏：算法学习

本文链接：https://blog.youkuaiyun.com/huiyudaoyi/article/details/80633780

算法学习专栏收录该内容

8 篇文章

订阅专栏

本文详细介绍了如何实现二叉树的层次遍历序列化，即将二叉树转化为水平顺序的字符串表示，以及如何进行反序列化，将字符串还原为原来的二叉树结构。通过深度优先搜索和广度优先搜索两种方法，阐述了关键步骤和注意事项，适合初学者理解二叉树操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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;
    }
}