【剑指Offer】62、序列化二叉树

题目描述

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

二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。

二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

题解：递归

 public static String Serialize(TreeNode root) {
         //先序遍历
         if (root == null) {
             return "#_";
         }
         String res = root.val + "_";
         res+=Serialize(root.left);
         res += Serialize(root.right);
         return res;
     }
     /**
      * 将序列化字符串装入一个queue中
      */
     public static TreeNode Deserialize(String str) {
         Queue<String> queue = new LinkedList<>();
         Collections.addAll(queue, str.split("_"));
         return Deserialize(queue);
     }
     /**
      * 前序遍历反序列化
      * 从队列中取出一个判断是否是"#"，如果是表示该结点为null，否则新建结点
      */
     public static TreeNode Deserialize(Queue<String> queue) {
         String string = queue.poll();
         if (string.equals("#")) {
             return null;
         }
         TreeNode root = new TreeNode(Integer.parseInt(string));
         root.left = Deserialize(queue);
         root.right = Deserialize(queue);
         return root;
     }

初始化树：

 public static class TreeNode{
         int val=0;
         TreeNode left=null;
         TreeNode right=null;
         public TreeNode(int val){
             this.val=val;
         }
     }
 private static List<TreeNode> nodeList = null;
     public static TreeNode createBinTree(int[] array) {
         nodeList = new LinkedList<TreeNode>();
         // 将一个数组的值依次转换为TreeNode节点
         for (int nodeIndex = 0; nodeIndex < array.length; nodeIndex++) {
             nodeList.add(new TreeNode(array[nodeIndex]));
         }
         // 对前lastParentIndex-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);
         }
         // 最后一个父节点:因为最后一个父节点可能没有右孩子，所以单独拿出来处理
         int lastParentIndex = array.length / 2 - 1;
         // 左孩子
         nodeList.get(lastParentIndex).left = nodeList
                 .get(lastParentIndex * 2 + 1);
         // 右孩子,如果数组的长度为奇数才建立右孩子
         if (array.length % 2 == 1) {
             nodeList.get(lastParentIndex).right = nodeList
                     .get(lastParentIndex * 2 + 2);
         }
         return nodeList.get(0);
     }

层序遍历打印：

 public static ArrayList<ArrayList<Integer>> Print(TreeNode pRoot) {
         ArrayList<ArrayList<Integer>> res = new ArrayList<>();
         LinkedList<TreeNode> queue = new LinkedList<>();
         if(pRoot==null){
             return res;
         }
         queue.offer(pRoot);
         while (queue.size()!=0){
             int size=queue.size();
             ArrayList<Integer> list = new ArrayList<>();
             for(int i=0;i<size;i++) {
                 TreeNode node = queue.poll();
                 if(node==null){
                     continue;
                 }
                 list.add(node.val);
                 queue.offer(node.left);
                 queue.offer(node.right);
             }
             if(list.size()!=0){
                 res.add(list);
             }
         }
         return res;
     }

测试：

 public static void main(String[] args) {
         int[] tree={8,6,10,5,7,9,11};
         TreeNode root = createBinTree(tree);
         String serialize = Serialize(root);
         System.out.println(serialize);
         TreeNode deserialize = Deserialize(serialize);
         ArrayList<ArrayList<Integer>> lists = Print(deserialize);
         for (ArrayList<Integer> list : lists) {
             System.out.println(list);
         }
     }
 输出：
       8_6_5_#_#_7_#_#_10_9_#_#_11_#_#_
       [8]
     [6, 10]
   [5, 7, 9, 11]