序列化以及反序列化二叉树

有些问题需要把二叉树序列化，可用于传输或者保存等，当然，有些题目也需要你去序列化以及反序列化，你懂的！

二叉树的定义如下：

package com.hbut.bean;

public class TreeNode {
	private  TreeNode left;
	private TreeNode right;
	private int val;
	public TreeNode(int val) {
		super();
		this.val = val;
	}


	public TreeNode getLeft() {
		return left;
	}
	public void setLeft(TreeNode left) {
		this.left = left;
	}
	public TreeNode getRight() {
		return right;
	}
	public void setRight(TreeNode right) {
		this.right = right;
	}
	public int getVal() {
		return val;
	}
	public void setVal(int val) {
		this.val = val;
	}


	
}

二叉树的序列化以及反序列化如下：

package com.hbut.test;

import com.hbut.bean.TreeNode;

public class TestTree {

	//二叉树如下
	//			0
	//		1		2
	//	3		4
	
	//初始化树
	public static TreeNode initTree (){
		
		TreeNode root = new TreeNode(0);
		TreeNode one = new TreeNode(1);
		TreeNode two = new TreeNode(2);
		TreeNode three = new TreeNode(3);
		TreeNode four = new TreeNode(4);
		
		root.setLeft(one);
		root.setRight(two);
		
		one.setLeft(three);
		one.setRight(four);
		
		return root;
	}
	
	//先序遍历
	public static void preOrder(TreeNode root){
		if(root==null){
			return ;
		}
		System.out.print(root.getVal()+" ");
		preOrder(root.getLeft());
		preOrder(root.getRight());
	}
	
	//序列化二叉树
	public static String serialize(TreeNode root) {  
		
		StringBuilder builder = new StringBuilder();
		if(root==null){
			return "#,";
		}
		builder.append(root.getVal()+",");
		builder.append(serialize(root.getLeft()));
		builder.append(serialize(root.getRight()));
		return builder.toString();
	}
	
	//反序列化二叉树
	static int index=-1;
	public static TreeNode Deserialize(String str) {
		String [] s=str.split(",");
		index++;
		TreeNode node=null;
		if(index<str.length()){
			if(!"#".equals(s[index])){
				node = new TreeNode(Integer.parseInt(s[index]));
				node.setLeft(Deserialize(str));
				node.setRight(Deserialize(str));
			}
		}
		
		return node;
	}
	
	
	public static void main(String[] args) {
		TreeNode root=initTree();
		System.out.print("先序遍历：");
		preOrder(root);
		
		//测试序列化以及反序列化二叉树
		String s=serialize(root);
		System.out.println();
		System.out.print("序列化二叉树："+s);
		System.out.println();
		
		//反序列化二叉树
		System.out.print("反序列化二叉树后（先序遍历）：");
		preOrder(Deserialize(s));
	}

}

运行结果如下：

先序遍历：0 1 3 4 2 
序列化二叉树：0,1,3,#,#,4,#,#,2,#,#,
反序列化二叉树后（先序遍历）：0 1 3 4 2