LeetCode 449. Serialize and Deserialize BST

题目：

Serialization is the process of converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.

Design an algorithm to serialize and deserialize a binary search tree. There is no restriction on how your serialization/deserialization algorithm should work. You just need to ensure that a binary search tree can be serialized to a string and this string can be deserialized to the original tree structure.

The encoded string should be as compact as possible.

Note: Do not use class member/global/static variables to store states. Your serialize and deserialize algorithms should be stateless.

思路：

使用BFS，把所有空节点保存成null，对于非BST应该是唯一做法。BST只需要保存前序遍历就可以。

使用DFS，迭代的编码解码。利用BST左边>中间>右边的特性，可以不保存null，在解码时使用lower和upper判断是否是自己的左右节点。（这个递归我写了一下午，还是需要多做题啊）

代码：

/**
* Definition for a binary tree node.
* public class TreeNode {
*     int val;
*     TreeNode left;
*     TreeNode right;
*     TreeNode(int x) { val = x; }
* }
*/
public class Codec {

// Encodes a tree to a single string.
public String serialize(TreeNode root) {
StringBuffer sb = new StringBuffer();
serializeDFS(root,sb);
return sb.toString();
}

private void serializeDFS(TreeNode root,StringBuffer sb){
if(root==null) return;
sb.append(root.val+" ");
serializeDFS(root.left, sb);
serializeDFS(root.right, sb);
}

// Decodes your encoded data to tree.
public TreeNode deserialize(String data) {
if(data.length() == 0) return null;
String[] strArr = data.split(" ");
List<Integer> list = new ArrayList<>();
list.add(0);
return deserializeDFS(strArr,list,Integer.MIN_VALUE,Integer.MAX_VALUE);
}

private TreeNode deserializeDFS(String[] data,List<Integer> list,int lower,int upper){
//获取位置
int index = list.get(0);
//如果值不在当前范围返回null
int val = Integer.parseInt(data[index]);
if(val<lower||val>upper) return null;
//如果位置在最后直接返回
if(index==data.length-1) return new TreeNode(val);

//新建点,位置+1,可能有左右孩子
TreeNode node = new TreeNode(val);
list.set(0,++index);

// 下一节点在左边
if(Integer.parseInt(data[list.get(0)])<node.val){
node.left = deserializeDFS(data,list,lower,node.val);
}
// 下一节点在右边
if(Integer.parseInt(data[list.get(0)])>node.val){
node.right = deserializeDFS(data,list,node.val,upper);
}
return node;
}
}

// Your Codec object will be instantiated and called as such:
// Codec codec = new Codec();
// codec.deserialize(codec.serialize(root));

使用队列把BST的前序遍历恢复，小的数放到新队列，大的数放剩在原来的队列里，递归调用。利用了一个新队列，复杂度略高。

// some notes:
//   5
//  3 6
// 2   7
private TreeNode getNode(Queue<Integer> q) { //q: 5,3,2,6,7
if (q.isEmpty()) return null;
TreeNode root = new TreeNode(q.poll());//root (5)
Queue<Integer> samllerQueue = new LinkedList<>();
while (!q.isEmpty() && q.peek() < root.val) {
samllerQueue.offer(q.poll());
}
//smallerQueue : 3,2   storing elements smaller than 5 (root)
root.left = getNode(samllerQueue);
//q: 6,7   storing elements bigger than 5 (root)
root.right = getNode(q);
return root;
}