leetcode “297. serialize and deserialize binary tree”

public class Codec {
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        if (root == null) {
            return "";
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int level = 1; // from 1
        Map<TreeNode, Integer> indexMap = new HashMap<>();
        Map<Integer, String> stringMap = new HashMap<>();
        indexMap.put(root, 1); // index from 1
        while (!queue.isEmpty()) {
            Queue<TreeNode> queue2 = new LinkedList<>();
            while (!queue.isEmpty()) {
                TreeNode node = queue.poll();
                int index = indexMap.get(node);
                stringMap.put(index, String.valueOf(node.val));
                if (node.left != null) {
                    queue2.add(node.left);
                    indexMap.put(node.left, index * 2);
                }
                if (node.right != null) {
                    queue2.add(node.right);
                    indexMap.put(node.right, index * 2 + 1);
                }
            }
            if (!queue2.isEmpty()) {
                queue = queue2;
                level++;
            }
        }
        StringBuilder builder = new StringBuilder();
        builder.append(stringMap.get(1));
        for (int i = 2; i < Math.pow(2, level); i++) {
            builder.append(" ");
            if (stringMap.containsKey(i)) {
                builder.append(stringMap.get(i));
            } else {
                builder.append("null");
            }
        }
        // System.out.println(builder.toString());
        return builder.toString();
    }
    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if (data.length() < 1 || data.equals("null")) {
            return null;
        }
        String[] s = data.split(" ");
        TreeNode root = new TreeNode(Integer.parseInt(s[0]));
        this.dfs(s, root, 1);
        return root;
    }
    private void dfs(String[] s, TreeNode root, int index) {
        if (index * 2 + 1 > s.length || root == null) {
            return;
        }
        String left = s[index * 2 - 1];
        if (!left.equals("null")) {
            TreeNode leftNode = new TreeNode(Integer.parseInt(left));
            this.dfs(s, leftNode, index * 2);
            root.left = leftNode;
        }
        String right = s[index * 2];
        if (!right.equals("null")) {
            TreeNode rightNode = new TreeNode(Integer.parseInt(right));
            this.dfs(s, rightNode, index * 2 + 1);
            root.right = rightNode;
        }
    }
}

public class Codec {
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        StringBuilder builder = new StringBuilder();
        this.preorder(root, builder);
        return builder.toString();
    }
    private void preorder(TreeNode root, StringBuilder builder) {
        if (root == null) {
            builder.append("n").append(" ");
            return;
        }
        builder.append(String.valueOf(root.val)).append(" ");
        this.preorder(root.left, builder);
        this.preorder(root.right, builder);
    }
    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if (data.length() < 1) {
            return null;
        }
        Queue<String> queue = new LinkedList<>();
        queue.addAll(Arrays.asList(data.split(" ")));
        return this.dfs(queue);
    }
    private TreeNode dfs(Queue<String> queue) {
        if (queue.isEmpty()) {
            return null;
        }
        String str = queue.poll();
        if (str.equals("n") || str.length() < 1) {
            return null;
        }
        TreeNode node = new TreeNode(Integer.parseInt(str));
        node.left = this.dfs(queue);
        node.right = this.dfs(queue);
        return node;
    }
}