LeetCode-297. 二叉树的序列化和反序列化（最全解法）

-.- 这题不会做，记录下大佬的题解（难度：困难）

一、题目内容

序列化是将一个数据结构或者对象转换为连续的比特位的操作，进而可以将转换后的数据存储在一个文件或者内存中，同时也可以通过网络传输到另一个计算机环境，采取相反方式重构得到原数据。

请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

示例:
你可以将以下二叉树：

1
/
2 3
\
4

序列化为 “[null,null,null,4,2,null,null,3,1]”
提示: 这与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。

说明: 不要使用类的成员 / 全局 / 静态变量来存储状态，你的序列化和反序列化算法应该是无状态的。

二、题解过程

1、什么是序列化和反序列化

以如下的二叉树作为举例

serialize方法也许会把它序列化成字符串2,1,#,6,3,#,#，其中#,表示null指针，那么把这个字符串再输入deserialize方法，依然可以还原出这个二叉树。也就是说，这两个方法会成对使用，你只要保证他俩能完成任务就行了。
说明一下，二叉树是一个二维平面的结构，而序列化出来的字符串是一个线性的一维结构。所谓的序列化就是把二叉树中的数据打平，放在一维数组中，其实就是考察数组的遍历方式。
二叉树的遍历方式有哪些？
1）递归遍历方式有前序遍历，中序遍历，后续遍历；
2）迭代方式一般是层级遍历。

2、遍历算法分析及实现框架

1）前序遍历算法解题框架

void traverse(TreeNode root) {
	if (root == null) {
		return;
	}
	
	/***前序遍历代码***/
	
	traverse(root.left);
	traverse(root.right);
}

2）中序遍历算法解题框架

void traverse(TreeNode root) {
	if (root == null) {
		return;
	}
		
	traverse(root.left);
	/***中序遍历代码***/
	traverse(root.right);
}

3）后续遍历算法解题框架

void traverse(TreeNode root) {
	if (root == null) {
		return;
	}		
	traverse(root.left);	
	traverse(root.right);
	
	/***后序遍历代码***/
}

4）层级遍历框架

void traverse(TreeNode root) {
	if (root == null) {
		return;
	}		
	//初始化队列，将root 加入队列
	Queue<TreeNode> q = new LinkedList<>();
	q.offer(root);
	while (!q.isEmpty()) {
		TreeNode cur = q.poll();
		/****层级遍历的代码的位置*****/
		System.out.println(cur.value);
		if (cur.left != null) {
			q.offer(cur.left);
		}
		if (cur.right != null) {
			q.offer(cur.right);
		}
	}	
}

3、解法

解法一（前序遍历解法）

模型如下：
1
/ \
2 3
\
4
前序遍历压缩的字符串为“1，2，#，4，#，#，3，#，#”

class Codec {
    String NULL = "#";
    StringBuilder sb = new StringBuilder();
    String SEP = ",";

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        if (root == null) {
            return null;
        }
        serialize(root,sb);
        return sb.toString();
    }
    public void serialize(TreeNode root,StringBuilder sb) {
        if (root == null) {
            sb.append(NULL).append(SEP);
            return;
        }
        /*****前序遍历位置**********/
        sb.append(root.val).append(SEP);

        serialize(root.left,sb);
        serialize(root.right,sb);
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        LinkedList<String> nodes = new LinkedList<>();
        for(String s : data.split(",")) {
            nodes.addLast(s);
        }

        return deserialize(nodes);
    }
    public TreeNode deserialize(LinkedList<String> nodes) {
        if (nodes.isEmpty()) {
            return null;
        }
        /****** 前序遍历位置 ******/
        // 列表最左侧就是根节点
        String first = nodes.removeFirst();
        if (NULL.equals(first)) {
            return null;
        }
        /***********************/
        TreeNode root = new TreeNode(Integer.parseInt(first));
        root.left = deserialize(nodes);
        root.right = deserialize(nodes);

        return root;
    }
}

解法二（后续遍历解法）

模型如下：
1
/ \
2 3
\
4
后序遍历压缩的字符串为“#，#，#，4，2，#，#，3，1”

class Codec {
    String NULL = "#";
    StringBuilder sb = new StringBuilder();
    String SEP = ",";

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        if (root == null) {
            return null;
        }
        serialize(root,sb);
        return sb.toString();
    }
    public void serialize(TreeNode root,StringBuilder sb) {
        if (root == null) {
            sb.append(NULL).append(SEP);
            return;
        }
        serialize(root.left,sb);
        serialize(root.right,sb);

		 /*****后序遍历位置**********/
        sb.append(root.val).append(SEP);

    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        LinkedList<String> nodes = new LinkedList<>();
        for(String s : data.split(",")) {
            nodes.addLast(s);
        }
        return deserialize(nodes);
    }
    public TreeNode deserialize(LinkedList<String> nodes) {
        if (nodes.isEmpty()) {
            return null;
        }
        /****** 前序遍历位置 ******/
        // 列表最左侧就是根节点
        String last= nodes.removeLast();
        if (NULL.equals(last)) {
            return null;
        }
        /***********************/
        TreeNode root = new TreeNode(Integer.parseInt(last));
        root.right= deserialize(nodes);
        root.left= deserialize(nodes);

        return root;
    }
}

解法三（中续遍历解法）

此法无解，具体原因请自己思考

解法四（层级遍历解法）

模型如下：
1
/ \
2 3
\
4
层级遍历压缩的字符串为“1，2，3，#，4，#，#，#，#”

class Codec {
    String NULL = "#";
    String SEP = ",";
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        if (root == null) {
            return "";
        }
        Queue<TreeNode> queue = new LinkedList<>();
        StringBuilder sb = new StringBuilder();

        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode temp = queue.poll();
            if (temp == null) {
                sb.append(NULL).append(SEP);
                continue;
            }
            sb.append(root.val).append(SEP);
            queue.offer(root.left);
            queue.offer(root.right);
        }
        return sb.toString();
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        Queue<TreeNode> queue = new LinkedList<>();
        String[] nodes = data.split(",");
        TreeNode root = new TreeNode(Integer.parseInt(nodes[0]));
        queue.offer(root);
        for(int i = 1; i < nodes.length;) {
            //队列中的都是父节点
            TreeNode parent = queue.poll();
            String left = nodes[i++];
            if (!NULL.equals(left)) {
                parent.left = new TreeNode(Integer.parseInt(nodes[i]));
                queue.offer(parent.left);
            }else {
                parent.left = null;
            }

            String right = nodes[i++];
            if (!NULL.equals(right)) {
                parent.right = new TreeNode(Integer.parseInt(nodes[i]));
                queue.offer(parent.right);
            }else {
                parent.right = null;
            }
        }
        return root;
    }
}