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

普通二叉树序列化与反序列化

题目描述

序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改。序列化的结果是一个字符串，序列化时通过某种符号表示空节点（null），以 , 表示一个结点值的结束（null,）。

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

示例:

你可以将以下二叉树：

  1. 1

/ \ 2 3 / \ 4 5

序列化为 “[1,2,3,null,null,4,5]”

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

代码

  1. /**
  2.  * Definition for a binary tree node.
  3.  * public class TreeNode {
  4.  *     int val;
  5.  *     TreeNode left;
  6.  *     TreeNode right;
  7.  *     TreeNode(int x) { val = x; }
  8.  * }
  9.  */
  11. public class Codec {
  12.     private StringBuilder serializeCore(TreeNode root, StringBuilder sb) {
  13.         if (root == null) {
  14.             sb.append("null,");
  15.         } else {
  16.             // 先序遍历的次序序列化
  17.             sb.append(root.val + ",");
  18.             sb = serializeCore(root.left, sb);
  19.             sb = serializeCore(root.right, sb);
  20.         }
  21.         return sb;
  22.     }
  24.     // Encodes a tree to a single string.
  25.     public String serialize(TreeNode root) {
  26.         return serializeCore(root, new StringBuilder()).toString();
  27.     }
  29.     private TreeNode deserializeCore(List<String> list) {
  30.         if ("null".equals(list.get(0))) {
  31.             list.remove(0);
  32.             return null;
  33.         }
  34.         // 先序遍历的次序还原
  35.         TreeNode root = new TreeNode(Integer.parseInt(list.get(0)));
  36.         list.remove(0);
  37.         root.left = deserializeCore(list);
  38.         root.right = deserializeCore(list);
  39.         return root;
  40.     }
  42.     // Decodes your encoded data to tree.
  43.     public TreeNode deserialize(String str) {
  44.         String[] strArray = str.split(",");
  45.         List<String> list = new ArrayList<>(Arrays.asList(strArray));
  46.         return deserializeCore(list);
  47.     }
  48. }
  50. // Your Codec object will be instantiated and called as such:
  51. // Codec codec = new Codec();
  52. // codec.deserialize(codec.serialize(root));

二叉搜索树的序列化和反序列化

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

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

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

来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/serialize-and-deserialize-bst 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

代码

  1. public class Codec {
  3.     private StringBuilder postOrder(TreeNode root, StringBuilder sb) {
  4.         if (root == null) return sb;
  5.         sb.append(root.val);
  6.         sb.append(',');
  7.         postOrder(root.left, sb);
  8.         postOrder(root.right, sb);
  9.         return sb;
  10.     }
  12.     // Encodes a tree to a single string.
  13.     public String serialize(TreeNode root) {
  14.         StringBuilder sb = postOrder(root, new StringBuilder());
  15.         if (sb.length() > 0) sb.deleteCharAt(sb.length() - 1);
  16.         return sb.toString();
  17.     }
  19.     private TreeNode helper(List<String> list, int lower, int upper) {
  20.         if (list.isEmpty()) return null;
  22.         int val = Integer.parseInt(list.get(0));
  23.         if (val < lower || val > upper) return null;
  24.         list.remove(0);
  26.         TreeNode root = new TreeNode(val);
  27.         root.left = helper(list, lower, val);
  28.         root.right = helper(list, val, upper);
  29.         return root;
  30.     }
  32.     // Decodes your encoded data to tree.
  33.     public TreeNode deserialize(String data) {
  34.         if (data.isEmpty()) return null;
  35.         List<String> list = new ArrayList<>(Arrays.asList(data.split(",")));
  36.         return helper(list, Integer.MIN_VALUE, Integer.MAX_VALUE);
  37.     }
  38. }
  40. // Your Codec object will be instantiated and called as such:
  41. // Codec codec = new Codec();
  42. // codec.deserialize(codec.serialize(root));