leetcode **剑指 Offer 37. 序列化二叉树(2021.6.30) & **297. 二叉树的序列化与反序列化(tree与string相互转化)(2020.6.16)

二叉树 同时被 3 个专栏收录
60 篇文章 0 订阅
75 篇文章 1 订阅
32 篇文章 0 订阅

【题目】**剑指 Offer 37. 序列化二叉树 & **297. 二叉树的序列化与反序列化

**297. 二叉树的序列化与反序列化
606. 根据二叉树创建字符串

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

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

示例:

你可以将以下二叉树:

    1
   / \
  2   3
     / \
    4   5

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

提示: 这与 LeetCode 目前使用的方式一致,详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式,你也可以采用其他的方法解决这个问题。

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

【解题思路1】BFS

public class Codec {
    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        if(root == null) return "";
        StringBuilder res = new StringBuilder();
        Queue<TreeNode> queue = new LinkedList();
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode cur = queue.remove();
            if(cur == null){
                res.append("null,");
            }else{
                res.append(cur.val + ",");
                queue.add(cur.left);
                queue.add(cur.right);
            }
        }
        return res.toString();
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if(data.length() == 0) return null;
        String[] nodes = data.split(",");
        TreeNode root = getNode(nodes[0]);
        Queue<TreeNode> queue = new LinkedList();
        queue.offer(root);
        int index = 1;
        while(!queue.isEmpty()){
            TreeNode temp = queue.poll();
            if(!nodes[index].equals("null")) {
                temp.left = getNode(nodes[index]);
                queue.offer(temp.left);
            }
            index++;
            if(!nodes[index].equals("null")) {
                temp.right = getNode(nodes[index]);
                queue.offer(temp.right);
            }
            index++;
        }
        return root;
    }

    private TreeNode getNode(String val){
        if(val.equals("null")){
            return null;
        }
        return new TreeNode(Integer.valueOf(val));
    }
}

序列化 Serialize :
时间复杂度: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)。

反序列化 Deserialize:
时间复杂度:O(N)。N 为二叉树的节点数,按层构建二叉树需要遍历整个 vals ,其长度最大为 2N+1。
空间复杂度:O(N)。最差情况下,队列 queue 同时存储 (N+1)/2 个节点,因此使用 O(N)额外空间。

【解题思路2】DFS

public class Codec {
    public String rserialize(TreeNode root, String str) {
        if (root == null) {
            str += "None,";
        } else {
            str += str.valueOf(root.val) + ",";
            str = rserialize(root.left, str);
            str = rserialize(root.right, str);
        }
        return str;
    }

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        return rserialize(root, "");
    }

    public TreeNode rdeserialize(List<String> l) {
        if (l.get(0).equals("None")) {
            l.remove(0);
            return null;
        }
  
        TreeNode root = new TreeNode(Integer.valueOf(l.get(0)));
        l.remove(0);
        root.left = rdeserialize(l);
        root.right = rdeserialize(l);
    
        return root;
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        String[] data_array = data.split(",");
        List<String> data_list = new LinkedList<String>(Arrays.asList(data_array));
        return rdeserialize(data_list);
    }
}
  • 0
    点赞
  • 0
    评论
  • 1
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

相关推荐
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值