编程题—序列化和反序列化

题目描述

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

 

思路：（1）首先我们需要先构建一颗二叉树

                    构建二叉树的思路：第一步：将数组中的元素封装成TreeNode类型的节点装入nodeList链表中。

                                                     第二步：根据二叉树父亲节点与其对应孩纸节点的数学关系构建出来一颗二叉树。

                                                                    具体关系为：父亲节点下标从0-n/2-1,（但是遍历时终止条件需小于n/2-1）,因为最后一个父亲节可能没有右孩子；当n/2-1为奇数时，该父亲节点有右孩子；当n/2-1为偶数时，该父亲节点没有右孩子。

            （2）接下来进行序列化,即就是将这棵树转换为一个字符串的形式（比如：每个节点之间用！分隔，空节点用#表示）。

            （3）最后进行反序列化，即就是将字符串重新转化为原数组序列。

 

代码如下：

---

package com.cll.cn.leedcode;

import java.util.LinkedList;
import java.util.List;

/**
 * 序列化和反序列化二叉树
 * SerializeTree / Deserialize
 */
public class SerializeTree {
    //定义TreeNode类
    public static class TreeNode{
        public int val;
        public TreeNode left;
        public TreeNode right;

        public TreeNode(int val){
            this.left = null;
            this.right = null;
            this.val = val;
        }
    }

    public static int[] array = {1,2,3,4,5,6,7,8,9};
    public static List<TreeNode> nodeList = null;//定义一个链表存储二叉树

    //构建一颗二叉树
    private static void createBinaryTree(int[] array){
        nodeList = new LinkedList<>();
        //将一个数组的值转换为TreeNode节点
        for(int i=0;i < array.length; i++){
            nodeList.add(new TreeNode(array[i]));
        }
        //对前（parentIndex-1）个父亲节点按照与孩子的数字关系建立二叉树关系
        for(int parentIndex=0; parentIndex < array.length/2-1; parentIndex++){
            //左孩子
            nodeList.get(parentIndex).left = nodeList.get(parentIndex*2+1);
            //右孩子
            nodeList.get(parentIndex).right = nodeList.get(parentIndex*2+2);
        }

        //对于第（parentIndex-1）个父亲节点 分情况构建左右子树
        int mid = array.length/2 - 1;
        //左孩子
        nodeList.get(mid).left = nodeList.get(mid*2+1);
        //右孩子 如果数组的长度为奇数 才有右子树
        if(mid%2 == 1){
            nodeList.get(mid).right = nodeList.get(mid*2+2);
        }
    }

    //序列化
    private static String Serialize(TreeNode root){
        StringBuilder str = new StringBuilder();
        if(root == null){
            str.append("#!");
            return str.toString();
        }
        str.append(root.val+"!");
        str.append(Serialize(root.left));
        str.append(Serialize(root.right));

        return str.toString();
    }

    //反序列化
    public static int index = -1;
    private static TreeNode Deserialize(String str){
        index++;

        if(index >= str.length()) {
            return null;
        }
        String[] nodes = str.split("!");
        TreeNode root = null;
        if(!nodes[index].equals("#")){
            root = new TreeNode(Integer.valueOf(nodes[index]));
            root.left = Deserialize(str);
            root.right = Deserialize(str);
        }
        return root;
    }

    public static void main(String[] args){
        System.out.println("对数组1,2,3,4,5,6,7,8,9进行序列化和反序列化：");
        SerializeTree tree = new SerializeTree();
        tree.createBinaryTree(array);//创建一颗二叉树
        TreeNode root = nodeList.get(0);//获取根节点

        String res = tree.Serialize(root);
        System.out.println(res);

        TreeNode newRoot=tree.Deserialize(res);
        System.out.println(newRoot.val);

    }
}