BST：序列化

    给定一棵BST，实现序列化函数，把其序列化成为一个字符串，并实现还原函数，把字符串重新还原成一个二叉树。

    分析：因为BST的中序访问结果是一个有序数组，因此，只需要把前序访问结果序列化，还原时，可以根据前序得到的字符串和中序为有序数组这两个特点进行还原。

    还原过程可以参考二叉树中根据先序和中序还原二叉树的博客。

    但这里还有更简单的方法。如[8,6,10,5,7,9,11]这个BST，前序访问结果为[8,6,7,5,10,9,11]，8是根节点，而左子树的值都比8小，因此可以先把8取出来，然后8后面比8小的都是左子树的节点，剩下的是右子树的节点。递归执行，就可以把BST还原了。

public class Codec {
   // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        if(root == null)
            return ""; 
        Stack<TreeNode> stack = new Stack<TreeNode>();
        StringBuilder sb = new StringBuilder();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            sb.append(node.val).append(" ");
            if(node.right != null) stack.push(node.right);
            if(node.left != null) stack.push(node.left);
        }
        return sb.toString();
     }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        if(data.equals(""))
           return null;
        String[] strs = data.split(" ");
        Queue<Integer> queue = new LinkedList<Integer>();
        for(String str : strs){
            queue.offer(Integer.parseInt(str));
        }
        return getNodes(queue);
    }
    public TreeNode getNodes(Queue<Integer> queue){
        if(queue.isEmpty()){
            return null;
        }               
        TreeNode root = new TreeNode(queue.poll());
        Queue<Integer> smallQueue = new LinkedList<Integer>();
        while(!queue.isEmpty() && queue.peek() < root.val){
            smallQueue.offer(queue.poll());
        }
        root.left = getNodes(smallQueue);
        root.right = getNodes(queue);
        return root;
    }
}