leetcode 297. 二叉树的序列化与反序列化

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

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

示例:

你可以将以下二叉树：

1

/ \
2 3
/ \
4 5

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

思路：
对于构造序列化，因为是按层级遍历树，常用的前序中序后序都不好用，但遍历的基本顺序还是从上至下，可以使用FIFO队列，对于当前节点，把它的值添加到字符串，同时把它的左右子节点添加到队列中，因为null也要打印出来，所以如果子节点是null，也要加入队列中。使用队列可以保证节点在队列中是层级有序的

反序列化也可以用队列，只不过这个队列是进的同时也会出队列：先将字符串转为字符串数组，如果当前数组元素不是”null”字符串，构造当前节点加入队列，然后继续遍历数组元素，下面两个数组元素就是当前节点的左右子节点，如果左右子节点不是null，那么也构造节点加入队列；处理完子节点，就可以将当前节点从队列中出队列，然后取队列中下一个节点继续处理

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {
 static LinkedList<TreeNode> q;
    static StringBuilder sb;

    // Encodes a tree to a single string.
     public static String serialize(TreeNode root) {
        q = new LinkedList<TreeNode>();
        sb = new StringBuilder("[");
        if (root != null) {
            q.addFirst(root);
            visit(q);
        }
        if (sb.length() > 0) {
            sb.delete(sb.length() - 1,sb.length());
        }
        sb.append("]");
         while (sb.length() > 5 && sb.substring(sb.length()-6).equalsIgnoreCase(",null]")) {
            sb.delete( sb.length()-6,sb.length()-1);
        }

        return sb.toString();
    }

    public static void visit(LinkedList<TreeNode> q) {
        if (!q.isEmpty()) {
            TreeNode t = q.pollLast();
            if (null == t) {
                sb.append("null,");
            } else {
                sb.append( t.val + ",");
                if (t.left != null) {
                    q.addFirst(t.left);
                } else {
                    q.addFirst(null);
                }
                if (t.right != null) {
                    q.addFirst(t.right);
                } else {
                    q.addFirst(null);
                }
            }

            visit(q);
        }
    }

    // Decodes your encoded data to tree.
     public static TreeNode deserialize(String data) {
        if (null == data) {
            return null;
        }
        StringBuilder sb = new StringBuilder(data);
        if(sb.charAt(0) == '['){
            sb.delete(0, 1);
        }
        if(sb.charAt(sb.length()-1)==']'){
            sb.delete(sb.length()-1, sb.length());
        }

        TreeNode root = null;
        if (!"".equals(sb.toString())) {

            String[] A = sb.toString().split(",");
            int count = 1;
            LinkedList<TreeNode> fifo = new LinkedList<TreeNode>();
            root = new TreeNode(Integer.valueOf(A[0]));
            fifo.addFirst(root);
            while (count < A.length) {
                String temp = A[count++];
                if (temp.equals("null")) {
                    fifo.peekLast().left = null;
                } else {
                    fifo.peekLast().left = new TreeNode(Integer.valueOf(temp));
                    fifo.addFirst(fifo.peekLast().left);
                }
                if (count < A.length) {
                    temp = A[count++];
                    if (temp.equals("null")) {
                        fifo.peekLast().right = null;
                    } else {
                        fifo.peekLast().right = new TreeNode(Integer.valueOf(temp));
                        fifo.addFirst(fifo.peekLast().right);
                    }
                    fifo.pollLast();
                } else {
                    return root;
                }

            }


        }
        return root;
    }
}

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