LeetCode297、二叉树的序列化与反序列化

1、题目描述

https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/

2、解法

这里使用后序遍历解法：
我们知道仅仅知道一种遍历结果是无法还原一颗二叉树的，但是现在我们只需要序列化的时候，把空指针也序列化（如使用#表示）则我们是可以还原一个树出来的。

2.1、后序遍历

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {
    StringBuilder sb = new StringBuilder();
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        serializeR(root);
        return sb.toString();
        
    }
    public void serializeR(TreeNode root){
        if(root==null){
            sb.append("#"+",");
            return ;//#表示null结点
        } 
        serializeR(root.left);
        serializeR(root.right);
        //后序序列化
        sb.append(root.val+",");
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        //这是后序序列，则最后一个结点是根结点，而且这个序列的元素个数
        //满足完全二叉树
        LinkedList<String>nodeList = new LinkedList<>();
        String[]nodes = data.split(",");
        //将序列整合为结点集合
        for(String s:nodes){
            nodeList.addLast(s);
        }
        return deserialize(nodeList,nodes.length-1);
        
    }
    /*
    *length为元素下标索引最大值
    */
    private TreeNode deserialize( LinkedList<String>nodeList,int length){
        if(nodeList==null||length<0) return null;
        String s = nodeList.removeLast();
        TreeNode root=null;
        if(s.equals("#")) { 
            return root;
        }   
        else root = new TreeNode(Integer.parseInt(s));   //最后一个元素是root，紧接着就是它的左右子树结点
        root.right = deserialize(nodeList,length-1);//先右再左
        root.left = deserialize(nodeList,length-2);
        
        return root;
    }
}

// Your Codec object will be instantiated and called as such:
// Codec ser = new Codec();
// Codec deser = new Codec();
// TreeNode ans = deser.deserialize(ser.serialize(root));

2.1、前序遍历解法

前序遍历中，第一个结点就是根结点的位置，我们只需要知道这个，然后稍微修改上面的代码即可。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {
    StringBuilder sb = new StringBuilder();
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        serializeR(root);
        return sb.toString();
        
    }
    public void serializeR(TreeNode root){
        if(root==null){
            sb.append("#"+",");
            return ;//#表示null结点
        } 
          //前序序列化
        sb.append(root.val+",");
        serializeR(root.left);
        serializeR(root.right);
      
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        //这是前序序列，则最后一个结点是根结点，而且这个序列的元素个数
        //满足完全二叉树
        LinkedList<String>nodeList = new LinkedList<>();
        String[]nodes = data.split(",");
        //将序列整合为结点集合
        for(String s:nodes){
            nodeList.addLast(s);
        }
        return deserialize(nodeList);
        
    }
    /*
    *length为当前序列的长度
    */
    private TreeNode deserialize( LinkedList<String>nodeList){
        if(nodeList==null||nodeList.size()==0) return null;
        String s = nodeList.removeFirst();//第一个为root
        TreeNode root=null;
        if(s.equals("#")) { 
            return root;
        }   
        else root = new TreeNode(Integer.parseInt(s));   //最后一个元素是root
       
        root.left = deserialize(nodeList); 
        root.right = deserialize(nodeList);
        return root;
    }
}

// Your Codec object will be instantiated and called as such:
// Codec ser = new Codec();
// Codec deser = new Codec();
// TreeNode ans = deser.deserialize(ser.serialize(root));

运行结果：

2.3、中序遍历

无法知道根结点的位置所以无法恢复序列化，而只能进行序列化

2.4、层级遍历——广度优先遍历

二叉树的广度优先遍历又称按层次遍历。算法借助队列实现。
首先我们先回顾一下层级遍历的代码框架：
利用队列的先进先出的特点，从根开始，依次向下，对于每一层从左向右遍历。

void traverse(TreeNode root){
	if(root==null) return null;
	Queue<TreeNode> q = new LinkedList<>();
	q.offer(root);//第一层只有一个结点
	while(!q.isEmpty()){//队列不空
		TreeNode cur = q.poll();//将队头取出
		//遍历代码
//
//
		//完成一个结点的遍历，加入下一层
		if(cur.left!=null){//加入左
			q.offer(cur.left);
		}
		if(cur.right!=null){//加入右
			q.offer(cur.right);
		}
	}

}

标准的二叉树层级遍历，所以我们很容易就能写出层级序列化的代码（要记录空指针）：

String SEP = ",";
String NULL = "#";
/* 将二叉树序列化为字符串 */
String serialize(TreeNode root) {
    if (root == null) return "";
    StringBuilder sb = new StringBuilder();
    // 初始化队列，将 root 加入队列
    Queue<TreeNode> q = new LinkedList<>();
    q.offer(root);

    while (!q.isEmpty()) {
        TreeNode cur = q.poll();
        /* 层级遍历代码位置 */
        if (cur == null) {
            sb.append(NULL).append(SEP);
            continue;
        }
        sb.append(cur.val).append(SEP);
        /*****************/

        q.offer(cur.left);
        q.offer(cur.right);
    }

    return sb.toString();
}

那么这个时候层序遍历的序列有什么规律呢？每一层的个数按照完全二叉树方式递增。所以我们反序列化的时候，我们需要记录对应的子节点的位置。第一个是root，第二个的是root.left…这个代码看起来有点难，其实我们是一层一层的添加的，使用队列。

/* 将字符串反序列化为二叉树结构 */
TreeNode deserialize(String data) {
    if (data.isEmpty()) return null;
    String[] nodes = data.split(SEP);
    // 第一个元素就是 root 的值
    TreeNode root = new TreeNode(Integer.parseInt(nodes[0]));

    // 队列 q 记录父节点，将 root 加入队列
    Queue<TreeNode> q = new LinkedList<>();
    q.offer(root);
	//层级遍历中恢复序列
	for(int i=1;i<nodes.length;){
		TreeNode parent = q.poll();
		//现在取出当前父节点的下一层的左右子结点
		// 父节点对应的左侧子节点的值
	    String left = nodes[i++];
		//恢复
		if (!left.equals(NULL)) {//-------框架
	            parent.left = new TreeNode(Integer.parseInt(left));
	            q.offer(parent.left);//----------层序遍历代码
	        } else {
	            parent.left = null;//空指针不需要加入
	        }
		
	    // 父节点对应的右侧子节点的值
	    String right = nodes[i++];
	    if (!right.equals(NULL)) {//-------框架
	            parent.right = new TreeNode(Integer.parseInt(right));
	            q.offer(parent.right);//层序遍历代码
	        } else {
	            parent.right = null;//空指针不需要加入
	        }
	   }
	   return root;
}

运行结果：