二叉树3：介绍二叉树的序列化和反序列化

二叉树的序列化：
所谓序列化也就是持久化，把二叉树变成一个字符串来存放在一个文件里面。二叉树的序列化也诶有很多方式。一般都是使用先序序列化的方式，先介绍二叉树先序序列化的方式，假设序列化的结果字符串为str，初始时str等于空字符串。先序遍历二叉树，如果遇到空节点，就在str的末尾加上“#!”，“#”表示这个节点为空，节点值不存在，当然你也可以用其他的特殊字符，“!”表示一个值的结束。如果遇到不为空的节点，假设节点值为3，就在str的末尾加上“3!”，加#来占据空值的位置是拿来分辨左右子树的位置，避免出错。

加！的道理也是一样；反序列化也就是根据相应的顺序打印出二叉树。
代码：

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

public class Code_04_SerializeAndReconstructTree {

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[] values = preStr.split("!"); //分隔那个字符串，放进队列里面
Queue<String> queue = new LinkedList<String>();
for (int i = 0; i != values.length; i++) {
queue.offer(values[i]);
}
return reconPreOrder(queue);
}

public 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<Node>();
queue.offer(head);
while (!queue.isEmpty()) {
head = queue.poll();
if (head.left != null) {
res += head.left.value + "!";
queue.offer(head.left);
} else {
res += "#!";
}
if (head.right != null) {
res += head.right.value + "!";
queue.offer(head.right);
} else {
res += "#!";
}
}
return res;
}

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

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

// for test -- print tree
public static void printTree(Node head) { //把那颗二叉树打印出来
System.out.println("Binary Tree:");
printInOrder(head, 0, "H", 17);
System.out.println();
}

public static void printInOrder(Node head, int height, String to, int len) {
if (head == null) {
return;
}
printInOrder(head.right, height + 1, "v", len);
String val = to + head.value + to;
int lenM = val.length();
int lenL = (len - lenM) / 2;
int lenR = len - lenM - lenL;
val = getSpace(lenL) + val + getSpace(lenR);
System.out.println(getSpace(height * len) + val);
printInOrder(head.left, height + 1, "^", len);
}

public static String getSpace(int num) {
String space = " ";
StringBuffer buf = new StringBuffer("");
for (int i = 0; i < num; i++) {
buf.append(space);
}
return buf.toString();
}

也可看这篇博客理解：请点击这里