二叉搜索树的序列化和反序列化

二叉搜索树的序列化与反序列化，深度优先（递归实现）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
// Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        return seriCore(root);
    }

    private String seriCore(TreeNode root){
        //结束条件
        if(root == null){
            return "";
        }

        String ret = String.format("%d,", root.val);
        
        String left = seriCore(root.left);
        if(!"".equals(left)){
            ret += left + ",";
        }
        String right = seriCore(root.right);
        if(!"".equals(right)){
            ret += right + ",";
        }

        return ret.substring(0, ret.length() - 1);
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if(data == ""){
            return null;
        }

        String[] dataStrArray = data.split(",");
        int[] dataIntArray = new int[dataStrArray.length];
        for(int i = 0; i < dataStrArray.length; i++){
            dataIntArray[i] = Integer.valueOf(dataStrArray[i]);
        }

        return desCore(dataIntArray, 0, dataIntArray.length - 1);
    }

    private TreeNode desCore(int[] dataArray, int from, int to){
        //结束条件
        if(from > to){
            return null;
        }
        if(from == to){
            return new TreeNode(dataArray[from]);
        }

        int rootVal = dataArray[from];
        //寻找左子树
        int cur = from;
        while(cur <= to && dataArray[cur] <= rootVal){
            cur++;
        }
        
        TreeNode ret = new TreeNode(rootVal);
        ret.left = desCore(dataArray, from + 1, cur - 1);
        ret.right = desCore(dataArray, cur, to);

        return ret;
    }