[LEET-449] add 449

Author: fishercoder1534

leetcode-algorithms/README.md

@@ -32,6 +32,7 @@
 |454|[4Sum II](https://leetcode.com/problems/4sum-ii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/_4SumII.java) | O(n) |O(n) | Medium| HashMap
 |453|[Minimum Moves to Equal Array Elements](https://leetcode.com/problems/minimum-moves-to-equal-array-elements/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/MinimumMovestoEqualArrayElements.java)| O(n)|O(1) | Easy|
 |451|[Sort Characters By Frequency](https://leetcode.com/problems/sort-characters-by-frequency/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/SortCharactersByFrequency.java) | O(nlogn) |O(n) | Medium| HashMap
+|449|[Serialize and Deserialize BST](https://leetcode.com/problems/serialize-and-deserialize-bst/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/SerializeandDeserializeBST.java)| O(n)|O(h) | Medium| BFS
 |448|[Find All Numbers Disappeared in an Array](https://leetcode.com/problems/find-all-numbers-disappeared-in-an-array/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/FindAllNumbersDisappearedinanArray.java)| O(n)|O(1) | Easy| Array, HashMap
 |447|[Number of Boomerangs](https://leetcode.com/problems/number-of-boomerangs/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/NumberofBoomerangs.java)| O(n^2)|O(n) | Easy| HashMap
 |442|[Find All Duplicates in an Array](https://leetcode.com/problems/find-all-duplicates-in-an-array/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/FindAllDuplicatesinanArray.java)| O(n)|O(1) | Medium| Array
@@ -112,7 +113,7 @@
 |301|[Remove Invalid Parentheses](https://leetcode.com/problems/remove-invalid-parentheses/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/RemoveInvalidParentheses.java)| ? | ? | Hard| BFS
 |299|[Bulls and Cows](https://leetcode.com/problems/bulls-and-cows/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BullsandCows.java)| O(n)|O(1) | Easy| 
 |298|[Binary Tree Longest Consecutive Sequence](https://leetcode.com/problems/binary-tree-longest-consecutive-sequence/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BinaryTreeLongestConsecutiveSequence.java)| O(n)|O(n) | Medium | Tree
-|297|[Serialize and Deserialize Binary Tree](https://leetcode.com/problems/serialize-and-deserialize-binary-tree/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/SerializeandDeserializeBinaryTree.java)| ?|? | Hard|
+|297|[Serialize and Deserialize Binary Tree](https://leetcode.com/problems/serialize-and-deserialize-binary-tree/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/SerializeandDeserializeBinaryTree.java)| O(n) | O(h) | Hard| BFS
 |296|[Best Meeting Point](https://leetcode.com/problems/best-meeting-point/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/BestMeetingPoint.java)| ?|? | Hard|
 |295|[Find Median from Data Stream](https://leetcode.com/problems/find-median-from-data-stream/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/FindMedianFromDataStream.java)| O(nlogn) | O(n) | Hard| Heap
 |294|[Flip Game II](https://leetcode.com/problems/flip-game-ii/)|[Solution](../../master/leetcode-algorithms/src/main/java/com/stevesun/solutions/FlipGameII.java)| ? | ?| Medium| Backtracking

leetcode-algorithms/src/main/java/com/stevesun/common/classes/TreeNode.java

@@ -4,7 +4,16 @@ public class TreeNode {
     public int val;
     public TreeNode left;
     public TreeNode right;
-    
+
+    @Override
+    public String toString() {
+        return "TreeNode{" +
+                "val=" + val +
+                ", left=" + left +
+                ", right=" + right +
+                '}';
+    }
+
     public TreeNode(int x){this.val = x;}
 
     public TreeNode(TreeNode left, int val, TreeNode right) {

leetcode-algorithms/src/main/java/com/stevesun/solutions/SerializeandDeserializeBST.java

@@ -0,0 +1,62 @@
+package com.stevesun.solutions;
+
+import com.stevesun.common.classes.TreeNode;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * 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.
+ */
+public class SerializeandDeserializeBST {
+
+    // Encodes a tree to a single string.
+    public String serialize(TreeNode root) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        StringBuilder stringBuilder = new StringBuilder();
+        if (root == null) return stringBuilder.toString();
+        queue.offer(root);
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            for (int i = 0; i < size; i++) {
+                TreeNode curr = queue.poll();
+                if (curr == null) {
+                    stringBuilder.append("# ");
+                } else {
+                    stringBuilder.append(curr.val + " ");
+                    queue.offer(curr.left);
+                    queue.offer(curr.right);
+                }
+            }
+        }
+        return stringBuilder.toString();
+    }
+
+    // Decodes your encoded data to tree.
+    public TreeNode deserialize(String data) {
+        if (data == null || data.length() == 0) return null;
+        String[] nodes = data.split(" ");
+        TreeNode root = new TreeNode(Integer.valueOf(nodes[0]));
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+        for (int i = 1; i < nodes.length; i++) {
+            TreeNode curr = queue.poll();
+            if (!nodes[i].equals("#")) {
+                curr.left = new TreeNode(Integer.valueOf(nodes[i]));
+                queue.offer(curr.left);
+            }
+            if (!nodes[++i].equals("#")) {
+                curr.right = new TreeNode(Integer.valueOf(nodes[i]));
+                queue.offer(curr.right);
+            }
+        }
+        return root;
+    }
+
+}

leetcode-algorithms/src/main/java/com/stevesun/solutions/SerializeandDeserializeBinaryTree.java

@@ -31,7 +31,6 @@ public class SerializeandDeserializeBinaryTree {
      then eventually just return the root.
      */
 
-
     // Encodes a tree to a single string.
     public String serialize(TreeNode root) {
         if(root == null) return "";
@@ -77,5 +76,4 @@ public TreeNode deserialize(String data) {
         }
         return root;
     }
-
 }

leetcode-algorithms/src/test/java/com/stevesun/SerializeandDeserializeBSTTest.java

@@ -0,0 +1,34 @@
+package com.stevesun;
+
+import com.stevesun.common.classes.TreeNode;
+import com.stevesun.solutions.SerializeandDeserializeBST;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static junit.framework.Assert.assertEquals;
+
+public class SerializeandDeserializeBSTTest {
+    private static SerializeandDeserializeBST test;
+    private static TreeNode actualRoot;
+    private static TreeNode expectedRoot;
+
+    @BeforeClass
+    public static void setup(){
+        test = new SerializeandDeserializeBST();
+    }
+
+    @Before
+    public void setupForEachTest(){
+    }
+
+    @Test
+    public void test1(){
+        expectedRoot = new TreeNode(3);
+        expectedRoot.left = new TreeNode(1);
+        expectedRoot.right = new TreeNode(4);
+        expectedRoot.left.right = new TreeNode(2);
+        actualRoot = test.deserialize(test.serialize(expectedRoot));
+        assertEquals(expectedRoot.toString(), actualRoot.toString());
+    }
+}