JZ61 --- 序列化二叉树

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

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

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

例如，我们可以把一个只有根节点为1的二叉树序列化为"1,"，然后通过自己的函数来解析回这个二叉树。

题解：

题解一：递归
由题知：序列化时需要以 “#” 表示空结点，且每个结点之间以 “,” 分隔。
根据规则，递归实现序列化和反序列化。

public class Solution {

    // 实现二叉树的序列化和反序列化

    String Serialize(TreeNode root) {
        if(root == null){
            return "#";
        }else{
            return root.val + "," + Serialize (root.left) + "," + Serialize (root.right);
        }
    }


    // 根据字符串重新构造二叉树

    int index = 0;
    TreeNode Deserialize(String str) {
        String[] arr = str.split (",");
        index++;
        if(index > arr.length){
            return null;
        }
        TreeNode node = null;
        if(!arr[index].equals ("#")){
            node = new TreeNode (Integer.parseInt (arr[index]));
            node.left = Deserialize (str);
            node.right = Deserialize (str);
        }
        return node;
    }
}

题解二：非递归

public class Solution {
    // 序列化
    public static String Serialize(TreeNode root) {
        StringBuilder res = new StringBuilder ("");
        if(root == null) {
            return res.toString ();
        }
        res.append (root.val);
        Queue<TreeNode> queue = new LinkedList<> ();
        queue.offer (root);
        while (!queue.isEmpty ()) {
            TreeNode node = queue.poll ();
            if (node.left != null || node.right != null) {
                if (node.left == null) {
                    res.append (",#");
                } else {
                    res.append ("," + String.valueOf (node.left.val));
                    queue.offer (node.left);
                }
                if (node.right == null) {
                    res.append (",#");
                } else {
                    res.append ("," + String.valueOf (node.right.val));
                    queue.offer (node.right);
                }
            } else {
                // 叶子结点不需要处理
            }
        }

        return res.toString ();
    }

    // 反序列化
    public static TreeNode Deserialize(String str) {
        TreeNode root = null;
        if (str.equals ("")) {
            return root;
        }
        String[] arr = str.split (",");
        root = new TreeNode (Integer.parseInt (arr[0]));

        Queue<TreeNode> queue = new LinkedList<> ();
        queue.offer (root);
        int index = 1;
        while (!queue.isEmpty () && index < arr.length) {
            // 当前子树父结点
            TreeNode tmp = queue.poll ();
            if (index < arr.length && !arr[index].equals ("#")) {
                TreeNode left = new TreeNode (Integer.parseInt (arr[index]));
                tmp.left = left;
                index++;
                queue.offer (left);
            } else {
                index++;
            }
            if (index < arr.length && !arr[index].equals ("#")) {
                TreeNode right = new TreeNode (Integer.parseInt (arr[index]));
                tmp.right = right;
                index++;
                queue.offer (right);
            } else {
                index++;
            }
        }
        return root;
    }
}