Binary Tree Serialization and Deserialization

Design an algorithm and write code to serialize and deserialize a binary tree. Writing the tree to a file is called 'serialization' and reading back from the file to reconstruct the exact same binary tree is 'deserialization'.

There is no limit of how you deserialize or serialize a binary tree, you only need to make sure you can serialize a binary tree to a string and deserialize this string to the original structure.

hint:

http://www.geeksforgeeks.org/serialize-deserialize-binary-tree/

public class BTSerialize {
    class TreeNode {
        char val;
        TreeNode left, right;
        public TreeNode(char val) {
            this.val = val;
        }
    }
    public String serialization(TreeNode root) {
        StringBuilder str = new StringBuilder();
        if (root == null)
            return str.toString();
        TreeNode cur;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while (!stack.isEmpty()) {
            cur = stack.pop();
            if (cur.val == '#') {
                str.append("#,");
                continue;
            }
            str.append(cur.val);
            if (cur.left != null || cur.right != null) {
                str.append("|");
                if (cur.right != null) {
                    stack.push(cur.right);
                } else {
                    stack.push(new TreeNode('#'));
                }
                if (cur.left != null) {
                    stack.push(cur.left);
                } else {
                    stack.push(new TreeNode('#'));
                }
            }
            str.append(",");
        }
        return str.toString();
    }
    
    int idx = 0;
    public TreeNode deserialize(String data) {
        if (data == null || data.length() == 0) return null;
        String[] strs = data.split(",");
        TreeNode root = null;
        idx = 0;
        root = helpRead(root, strs);
        return root;
    }
    private TreeNode helpRead(TreeNode cur, String[] strs) {
        if (idx >= strs.length) return null;
        if (strs[idx].equals("#")) {
            idx++;
            return null;
        } else {
            int len = strs[idx].length();
            if (strs[idx].charAt(len-1) == '|') {
                char val = strs[idx].charAt(0);
                cur = new TreeNode(val);
                idx++;
                cur.left = helpRead(cur.left, strs);
                cur.right = helpRead(cur.right, strs);
                return cur;
            } else {
                char val = strs[idx].charAt(0);
                cur = new TreeNode(val);
                idx++;
                return cur;
            }
        }
    }
    
    public static void main(String[] args) {
        BTSerialize sol = new BTSerialize();
        TreeNode node0 = sol.new TreeNode('A');
        TreeNode node1 = sol.new TreeNode('B');
        TreeNode node2 = sol.new TreeNode('C');
        TreeNode node3 = sol.new TreeNode('D');
        TreeNode node4 = sol.new TreeNode('E');
        TreeNode node5 = sol.new TreeNode('F');
        TreeNode node6 = sol.new TreeNode('G');
        node0.left = node1; node0.right = node2;
        node1.left = node3; node1.right = node4;
        node2.left = node5;
        node3.right = node6;
        String str = sol.serialization(node0);
        System.out.println(str);
        TreeNode root = sol.deserialize(str), cur;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()) {
            cur = stack.pop();
            System.out.print(cur.val+", ");
            if (cur.right != null) stack.push(cur.right);
            if (cur.left != null) stack.push(cur.left);
        }
    }
}
/*
             A
         /       
        B         C
      /         /  
     D     E    F    
                   
       G           
*/