Thinking process

public class Codec {
    private static final String NULL_CHAR = "#";
    private static final String SPLIT_CHAR = ",";
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        StringBuilder result = new StringBuilder();
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);

        while (!q.isEmpty()) {
            TreeNode node = q.poll();

            if (result.length() != 0) result.append(SPLIT_CHAR);

            if (node != null) {
                result.append(node.val);
                q.offer(node.left);
                q.offer(node.right);
            } else {
                result.append(NULL_CHAR);
            }
        }

        return result.toString();
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String s) {
        String[] data = s.split(SPLIT_CHAR);
        if (data.length == 0 || data[0].equals(NULL_CHAR)) return null;

        Queue<TreeNode> q = new LinkedList<>();

        int i = 0;

        TreeNode head = new TreeNode(Integer.valueOf(data[i]));
        q.offer(head);

        while (!q.isEmpty()) {
            int size = q.size();

            for (int j = 0; j < size; ++j) {
                TreeNode node = q.poll();

                if (i + 1 < data.length) {
                    i++;
                    if (!data[i].equals(NULL_CHAR)) {
                        node.left = new TreeNode(Integer.valueOf(data[i]));
                        q.offer(node.left);
                    }
                }

                if (i + 1 < data.length) {
                    i++;
                    if (!data[i].equals(NULL_CHAR)) {
                        node.right = new TreeNode(Integer.valueOf(data[i]));
                        q.offer(node.right);
                    }
                }
            }
        }

        return head;

    }
}

N-ary tree

class TreeNode {
    public int val;
    public TreeNode[] children;

    public TreeNode(int v, int num) {
        this.val = v;
        children = new TreeNode[num];
    }
}

public class SerializationAndDeserializationNTree {
    private static final String NODE_SPLITER = "#";
    private static final String NUM_SPLITER = ",";

    private TreeNode deserialize(String str) {
        if (str.length() == 0) return null;

        //split input by #
        String[] values = str.split(NODE_SPLITER);

        //queue
        Queue<TreeNode> queue = new LinkedList<>();

        //root
        TreeNode root = new TreeNode(Character.getNumericValue(values[0].charAt(0)), 
            Character.getNumericValue(values[0].charAt(2)));
        queue.add(root);

        int index = 1;
        //loop
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();

            for (int i = 0; i < node.children.length; ++i) {
                TreeNode child = new TreeNode(Character.getNumericValue(values[index].charAt(0)), 
                    Character.getNumericValue(values[index].charAt(2)));
                node.children[i] = child;
                queue.offer(child);
                index++;
            }

        }
        //return node
        return root;
    }

    private String serialize(TreeNode root) {
        StringBuilder result = new StringBuilder();
        //queue
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        //loop
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();

            if (result.length() != 0) {
                result.append(NODE_SPLITER);
            }
            result.append(node.val);
            result.append(NUM_SPLITER);
            result.append(node.children.length);

            for (int i = 0; i < node.children.length; ++i) {
                queue.offer(node.children[i]);
            }

        }

        //return
        return result.toString();
    }