Leetcode: Serialize and Deserialize Binary Tree

Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.

Design an algorithm to serialize and deserialize a binary tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized to a string and this string can be deserialized to the original tree structure.

For example, you may serialize the following tree

    1
   / 
  2   3
     / 
    4   5
as "[1,2,3,null,null,4,5]", just the same as how LeetCode OJ serializes a binary tree. You do not necessarily need to follow this format, so please be creative and come up with different approaches yourself.
Note: Do not use class member/global/static variables to store states. Your serialize and deserialize algorithms should be stateless.

Referring this post: https://leetcode.com/problems/serialize-and-deserialize-binary-tree/discuss/74253/Easy-to-understand-Java-Solution

But instead using deque, use queue instead.

queue inherits addAll() function from java.util.Collection interface.

queue itself has poll() function to remove the head of the queue.

We can actually use queue, linkedlist, deque here as the variable type, but the actually implementation should allways be linkedlist.

if we define the type to be List<String>, it won't work because List doesn't have poll() function

Also notice that split() will not have trailing empty strings in the result array.

Some static functions:

Arrays.asList(int[] arr);    // array to List

String.valueOf(int i); 　　// int to String

Integer.valueOf(String s);  // String to int

public class Codec {
    final String spliter = ",";
    final String NN = "X";

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        buildString(root, sb);
        return sb.toString();
    }
    
    public void buildString(TreeNode node, StringBuilder sb) {
        if (node == null) {
            sb.append(NN).append(spliter);
            return;
        }
        sb.append(node.val).append(spliter);
        buildString(node.left, sb);
        buildString(node.right, sb);
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        Queue<String> queue = new LinkedList<> ();
        queue.addAll(Arrays.asList(data.split(spliter)));
        return constructTree(queue);
    }
    
    public TreeNode constructTree(Queue<String> queue) {
        String val = queue.poll();
        if (val.equals(NN)) return null;
        TreeNode node = new TreeNode(Integer.valueOf(val));
        node.left = constructTree(queue);
        node.right = constructTree(queue);
        return node;
    }
}

Follow Up:

如果已经知道这个Binary Tree的size为T, 怎么估计输出链表size？

答案是 2*T+1,    (假设tree perfect and complete, leaf node层有大概一半的node数，比之前所有层的node数之和还要多一，那么，最后一层node每个再派生两个“#”， 个数就会有T+1个，所以总共有2*T+1个)