剑指offer37之序列化和反序列化二叉树

前言

给定一颗二叉树，设计函数将其序列化字符串；给定字符串，将其序列化为二叉树。

Code

// offer 37 序列化二叉树
class Serialization {
    StringBuilder sb = new StringBuilder("[");
    TreeNode root;
    int maxLayer = 0;

    //求树的高度
    private void getMaxLayer(TreeNode root, int layer) {
        if (root == null) {
            maxLayer = (layer > maxLayer) ? layer : maxLayer;
            return;
        }
        getMaxLayer(root.left, layer + 1);
        getMaxLayer(root.right, layer + 1);
    }

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        if (root == null)
            return "[]";
        getMaxLayer(root, 0);
        //需要的是层次遍历
        layerOrder(root);
        int len = sb.length() - 1;
        char lastC = sb.charAt(len);
        if (lastC == ',') {
            sb.deleteCharAt(len);
        }
        sb.append(']');
        return sb.toString();
    }

    //根据树的高度来获取层序序列，像是求树的宽度
    private void layerOrder(TreeNode root) {
        int cur_count = 1, next_count = 0, cur_layer = 1;
        Queue<TreeNode> queue = new ArrayDeque<>();
        queue.add(root);
        sb.append(root.val).append(',');
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            if (node.left != null) {
                queue.add(node.left);
                sb.append(node.left.val).append(',');
                next_count++;
            } else if (cur_layer < maxLayer) {
                sb.append("null").append(',');
            }
            if (node.right != null) {
                queue.add(node.right);
                sb.append(node.right.val).append(',');
                next_count++;
            } else if (cur_layer < maxLayer) {
                sb.append("null").append(',');
            }
            if (--cur_count == 0) {
                cur_count = next_count;
                next_count = 0;
                cur_layer++;
            }
        }
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        data = data.substring(1, data.length() - 1);
        String[] nodesS = data.split(",");
        System.out.println(Arrays.toString(nodesS));
        Deque<TreeNode> ad = new ArrayDeque<>();
        //空字符串split之后有一个字符串，即空字符串。
        if (nodesS.length == 1 && "".equals(nodesS[0]))
            return root;
        root = new TreeNode(Integer.parseInt(nodesS[0]));
        ad.add(root);
        for (int i = 1; i < nodesS.length; i += 2) {
            TreeNode root = ad.pollFirst();
            if (!nodesS[i].equals("null")) {
                //字符可能是负数，所以不能去单纯-‘0’
                TreeNode leftN = new TreeNode(Integer.parseInt(nodesS[i]));
                root.left = leftN;
                ad.add(leftN);
            }
            if (i + 1 < nodesS.length && !nodesS[i + 1].equals("null")) {
                TreeNode rightN = new TreeNode(Integer.parseInt(nodesS[i + 1]));
                root.right = rightN;
                ad.add(rightN);
            }
        }
        return root;
    }
}

总结

1）这是一个综合的问题，对树的宽度，高度等都有考察。