每日一题

题目信息

• 时间： 2019-06-29

• 题目链接：Leetcode

• tag：序列化 二叉树 队列

• 难易程度：中等

• 题目描述：

  请实现两个函数，分别用来序列化和反序列化二叉树。

示例:

    1
   / 
  2   3
     / 
    4   5

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

解题思路

本题难点

题目要求的 “序列化” 和 “反序列化” 是 可逆 操作。因此，序列化的字符串应携带 “完整的” 二叉树信息，即拥有单独表示二叉树的能力。

具体思路

序列化的字符串实际上是二叉树的 “层序遍历”（BFS）结果。为使反序列化可行，考虑将越过叶节点后的 null 也看作是节点。

• **序列化 serialize **：借助队列，对二叉树做层序遍历，并将越过叶节点的 null 也打印出来。
• 反序列化 deserialize ：利用队列按层构建二叉树，借助一个指针 i 指向节点 node 的左、右子节点，每构建一个 node 的左、右子节点，指针 i 就向右移动 1 位。

代码

public class Codec {

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
      //若 root 为空，则直接返回空列表 "[]" ；
        if(root == null){
            return "[]";
        }
      //队列 queue （包含根节点 root ）
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
      //序列化列表 res 
        StringBuilder res = new StringBuilder("[");
        while(!queue.isEmpty()){
          //节点出队，记为 node ；
            TreeNode node = queue.poll();
            if(node != null){//若 node 不为空：打印字符串 node.val ，
                res.append(node.val).append(",");
              //将左、右子节点加入 queue 
                queue.add(node.left);
                queue.add(node.right);
            }else{//否则（若 node 为空）：打印字符串 "null"
                res.append("null").append(",");
            }
        }
      //拼接列表（去除最后一个节点后的 ',' 隔开，首尾添加中括号）
        res.deleteCharAt(res.length() - 1);
        res.append("]");
      //返回序列化结果
        return res.toString();
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
      // 若 data 为空，直接返回 null ；
        if(data == "[]"){
            return null;
        }
      //序列化列表 value （先去掉首尾中括号，再用逗号隔开）
        String[] value = data.substring(1,data.length() - 1).split(",");
      //根节点 root （值为 vals[0] ）
        TreeNode root = new TreeNode(Integer.parseInt(value[0]));
      //队列 queue（包含 root ）
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
      //指针i
        int i = 1;
        while(!queue.isEmpty()){
          //节点出队，记为 node ；
            TreeNode node = queue.poll();
          //构建 node 的左子节点：node.left 的值为 value[i] ，并将 node.left 入队；
            if(!value[i].equals("null")){
                node.left = new TreeNode(Integer.parseInt(value[i])); 
                queue.add(node.left);
            }
          //指针加一，找下一个节点
            i++;
          //构建 node 的右子节点：node.left 的值为 value[i] ，并将 node.left 入队；
            if(!value[i].equals("null")){
                node.right = new TreeNode(Integer.parseInt(value[i])); 
                queue.add(node.right);
            }
          //指针加一，找下一个节点
            i++;
        }
      //返回根节点root
        return root;
    }
}

复杂度分析：

• 时间复杂度 O(N) ： N 为二叉树的节点数，层序遍历需要访问所有节点，最差情况下需要访问 N+1 个 null ，总体复杂度为 O(2N+1)=O(N) 。
• 空间复杂度 O(N) ： 最差情况下，队列 queue 同时存储 N+1/2个节点（或 N+1 个 null ），使用 O(N) ；列表 res 使用 O(N) 。

其他优秀解答

解题思路

我们可以根据前序遍历的顺序来序列化二叉树,因为前序遍历是从根节点开始的。在遍历二叉树碰到 null时,将其序列化为一个特殊的字符(如'$')，节点的数值之间要用一个特殊字符(如',')隔开,因为节点的值位数不定且正负不定。

代码

 		int start=0;//注意这里必须是全局变量，否则后面的迭代过程中start无法正确变化
    public String serialize(TreeNode root) {
        if(root==null) return "$";
        StringBuilder res = new StringBuilder();
        recur(root,res);
        return res.toString();
    }
    public void recur(TreeNode root,StringBuilder res){//前序遍历
        if(root==null){ 
            res.append("$,");//可以append string
            return;}
        res.append(root.val);//append int 由于int位数不定，且可正可负，因此各元素间必须用,分割
        res.append(',');//append char
        recur(root.left,res);
        recur(root.right,res);
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if(data.equals("$")) return null;//Sting值相等的判别不能用==
        String inputs[] = data.split(",");
        //虽然data中以,结尾，但是上述分割后会默认最后一个,不存在  不会使最后一个分割元素为空
        return build(inputs);
    }
    public TreeNode build(String[] inputs){
        TreeNode res;
        if(inputs[start].equals("$")){ 
            start++;
            return null;//这里说明当前节点为null，自然不存在左右节点了，直接返回
        }
        res = new TreeNode(Integer.parseInt(inputs[start]));
        start++;
        //注意：start不能以形参的形式引入build方法中，build(inputs,start);如果是这样
        //下面res.left = build(inputs,start); res.right = build(inputs,start+1);由于处于同一级迭代中start值连续
        //但实际上res.right中应该是上面res.left迭代完成后才会执行的，start不连续，因此把start作为全局变量较为合适
        res.left = build(inputs);
        res.right = build(inputs);
        return res;
    }
}