LeetCode题解——449. 序列化和反序列化二叉搜索树(二叉搜索树的特性)

https://leetcode-cn.com/problems/serialize-and-deserialize-bst

题目

序列化是将数据结构或对象转换为一系列位的过程，以便它可以存储在文件或内存缓冲区中，或通过网络连接链路传输，以便稍后在同一个或另一个计算机环境中重建。

设计一个算法来序列化和反序列化二叉搜索树。 对序列化/反序列化算法的工作方式没有限制。 您只需确保二叉搜索树可以序列化为字符串，并且可以将该字符串反序列化为最初的二叉搜索树。

编码的字符串应尽可能紧凑。

注意：不要使用类成员/全局/静态变量来存储状态。 你的序列化和反序列化算法应该是无状态的。

思路

（1）增加标记位，用作反序列化分隔符
（2）序列化时，递归调用，null用n代替，反序列化时n变成Integer.MIN_VALUE
（3）利用左小右大的特性，可以找到左子树和右子树的区间范围，递归构建左子树和右子树

代码

static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
            val = x;
        }
    }

    static class Codec {

        // Encodes a tree to a single string.
        public String serialize(TreeNode root) {
            if (root == null) {
                return "n";
            }
            String rootString = String.valueOf(root.val);
            String leftString = serialize(root.left);
            String rightString = serialize(root.right);
            return rootString + "," + leftString + "," + rightString;
        }


        // Decodes your encoded data to tree.
        public TreeNode deserialize(String data) {
            List<Integer> list = new ArrayList<>(Arrays.asList(data.split(","))).stream().map(s -> {
                if (s.equals("n")) {
                    return Integer.MIN_VALUE;
                }
                return Integer.valueOf(s);
            }).collect(Collectors.toList());


            return core(list, 0, list.size() - 1);
        }

        public TreeNode core(List<Integer> list, int begin, int end) {
            if (begin >= list.size()) {
                return null;
            }
            if (begin > end) {
                return null;
            }
            if (begin == end) {
                if (list.get(begin) == Integer.MIN_VALUE) {
                    return null;
                }
                return new TreeNode(list.get(begin));
            }
            if (list.get(begin) == Integer.MIN_VALUE) {
                return null;
            }
            TreeNode root = new TreeNode(list.get(begin));
            if (end - begin == 2) { // 长度是3,说明是叶子结点了,后面必定只跟了2个null
                root.left = null;
                root.right = null;
                return root;
            }
            // 执行到此,说明一定有左子树或者有右子树(长度大于3)
            int leftEndIndex = findLeftEndIndex(list, begin + 1, end, root.val);
            TreeNode left = core(list, begin + 1, leftEndIndex);
            TreeNode right = core(list, leftEndIndex + 1, end);
            root.left = left;
            root.right = right;
            return root;
        }

        /**
         * 找到左子树最右索引
         */
        public int findLeftEndIndex(List<Integer> list, int begin, int end, int mid) {
            for (int i = begin; i < end; i++) {
                if (list.get(i) < mid && list.get(i + 1) > mid) {
                    return i;
                }
            }
            // 执行到此,说明没有右子树,那end就是左子树最右侧索引
            return end;
        }
    }