在LeetCode第一次写出400+ms时间 360+MB内存的代码。。。。。

第一次写出这么慢的代码，看到这个速度和内存消耗，不禁陷入了沉思。。。。。。我还以为我写了一整个游戏出来，毕竟360多MB的内存消耗，有点夸张。
果然不能滥用java的集合类。
贴出代码慢慢优化。。。
LeetCode449

public class Codec {

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        return serializeCore(root, sb);
    }

    private String serializeCore(TreeNode root, StringBuilder sb) {
        if (root == null){
            sb.append("#,");
        }else {
            sb.append(root.val).append(",");
            serializeCore(root.left, sb);
            serializeCore(root.right, sb);
        }

        return String.valueOf(sb);
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
    //一看估计就是这里慢的要死，说实话用着还挺方便的
        String[] strings = data.split(",");
        LinkedList<String> list = new LinkedList<>();
        Collections.addAll(list, strings);

        return deserializeCore(list);
    }

    private TreeNode deserializeCore(LinkedList<String> sb) {
        if (sb.get(0).equals("#")){
            sb.remove(0);
            return null;
        }
        TreeNode root = new TreeNode(Integer.parseInt(sb.get(0)));
        sb.remove(0);
        root.left = deserializeCore(sb);
        root.right = deserializeCore(sb);

        return root;
    }
}

先从递归入手吧，改成非递归的层次遍历吧
好了，序列化的改成层次遍历完成，将null结点替换为#字符。

public static String serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node == null){
                sb.append("#,");
            }else {
                sb.append(node.val).append(",");
                queue.offer(node.left);

                queue.offer(node.right);

            }
        }
        return sb.toString();
    }

下面是反序列化过程，其实思路不难。

public TreeNode deserialize(String data) {
        String[] strings = data.split(",");
        if (strings.length == 1 && strings[0].equals("#")){
            return null;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        TreeNode head = new TreeNode(Integer.parseInt(strings[0]));
        queue.offer(head);
        int index = 1;
        while (index < strings.length) {
            TreeNode node = queue.poll();
            if (node != null) {
                TreeNode left = strings[index].equals("#") ? null : new TreeNode(Integer.parseInt(strings[index]));
                index++;
                queue.offer(left);
                node.left = left;

                TreeNode right = strings[index].equals("#") ? null : new TreeNode(Integer.parseInt(strings[index]));
                index++;
                queue.offer(right);
                node.right = right;
            }
        }
        return head;
    }

再次提交：进步很大，不过相比还是慢了，唯一可能的点可能就在于split()方法了

继续改进split()这个点，为什么需要这个方法，因为一个个取出String data里的值，换一种方式来看看。
如果是"2,1,3,4,5,#,#,7,#,#,#,#,#,"序列化的结果，这好说，直接隔着两个取，但是如果是多位数了，则需要扫描直到“,”为止，涉及到了字符串转整数，感觉有点偏离题意了。
所以上面的方法也就可以了。