序列化二叉树

原创于 2019-04-24 11:48:05 发布 · 194 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#二叉树 #序列化 #java #数据结构与算法

算法总结专栏收录该内容

55 篇文章

订阅专栏

本文探讨了二叉树的序列化与反序列化问题，提出了三种不同的实现思路，包括使用前中后序遍历、层序遍历以及优化的前序遍历方法。通过具体的代码示例，详细解释了每种方法的实现过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题描述

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

思路描述

a) 思路一：首先想到的就是这个思路，先计算出二叉树的前序、中序、后序遍历中的两个，将这2个遍历结果作为序列化后的字符串中的主要内容；解析时，拿到这两个遍历结果，重构二叉树即可。（刷题时忘了重构二叉树的思路，就没用这个方法）
b) 思路二：根据层序遍历结果，将二叉树序列化为字符串，然后根据层序结果重构二叉树 – 应该借助split函数来解析字符串的。
c) 思路三（最优解）：用前序遍历，并用特定的字符代替空节点，然后用递归的方式重构字符串。

代码

a) 思路二代码：

String Serialize(TreeNode root) {
    if (root==null) return "";

    StringBuffer res = new StringBuffer();
    ArrayList<TreeNode> curLayer = new ArrayList<TreeNode>();
    curLayer.add(root);

    while(true){
        res.append("L");
        ArrayList<TreeNode> nextLayer = new ArrayList<TreeNode>();
        boolean hasNextLayer = false;
        for(TreeNode node:curLayer){
            if(node!=null) {
                hasNextLayer=true;
            }
            res.append(node==null?"N#":(node.val+"#"));
            nextLayer.add(node==null?null:node.left);
            nextLayer.add(node==null?null:node.right);
        }
        if(!hasNextLayer) break;
        curLayer=nextLayer;
    }
    return res.toString();
}
TreeNode Deserialize(String str) {

    if (str.equals("")) return null;

    int valStartIndex=0;
    ArrayList<ArrayList<TreeNode>>nodeBuffer=new ArrayList<ArrayList<TreeNode>>();
    ArrayList<TreeNode> curLayer = new ArrayList<TreeNode>();
    for(int i=0;i<str.length();i++){
        char c=str.charAt(i);
        if(c=='L'){
            valStartIndex=i+1;
            if (curLayer.size()!=0) {
                nodeBuffer.add(curLayer);
                curLayer = new ArrayList<TreeNode>();
            }
        }else if(c=='#'){
            if(i==valStartIndex+1 && str.charAt(valStartIndex)=='N'){
                curLayer.add(null);
            }else{
                int val = Integer.valueOf(str.substring(valStartIndex,i));
                curLayer.add(new TreeNode(val));
            }
            valStartIndex=i+1;
        }
    }

    TreeNode root = nodeBuffer.get(0).get(0);
    int layerNums = nodeBuffer.size();
    for(int i=0;i<layerNums-1;i++){
        curLayer = nodeBuffer.get(i);
        ArrayList<TreeNode> nextLayer = nodeBuffer.get(i+1);
        int counter=0;
        for(TreeNode node:curLayer){
            if (node!=null){
                node.left =nextLayer.get(counter);
                node.right=nextLayer.get(counter+1);
            }
            counter+=2;
        }
    }
    return root;
}

b)	思路三代码：
public class BetterSerialTree {
    
        public int index = -1;
        
        String Serialize(TreeNode root) {
            StringBuffer sb = new StringBuffer();
            if(root == null){
                sb.append("#,");
                return sb.toString();
            }
            sb.append(root.val + ",");
            sb.append(Serialize(root.left));
            sb.append(Serialize(root.right));
            return sb.toString();
        }
        TreeNode Deserialize(String str) {
            index++;
            int len = str.length();
            if(index >= len){
                return null;
            }
            String[] strr = str.split(",");
            TreeNode node = null;
            if(!strr[index].equals("#")){
                node = new TreeNode(Integer.valueOf(strr[index]));
                node.left = Deserialize(str);
                node.right = Deserialize(str);
            }

            return node;
        }
    
}