IsomorphicStrings: done

Author: rampatra

src/main/java/com/leetcode/graphs/WordLadder.java

@@ -102,8 +102,20 @@ public static int ladderLength(String beginWord, String endWord, List<String> wo
         return 0;
     }
 
+    /**
+     * TODO: Optimized both end BFS solution
+     *
+     * @param beginWord
+     * @param endWord
+     * @param wordList
+     * @return
+     */
+    public static int ladderLengthOptimized(String beginWord, String endWord, List<String> wordList) {
+        return -1;
+    }
+
     public static void main(String[] args) {
         assertEquals(5, ladderLength("hit", "cog", Arrays.asList("hot", "dot", "dog", "lot", "log", "cog")));
         assertEquals(0, ladderLength("hit", "cog", Arrays.asList("hot", "dot", "dog", "lot", "log")));
     }
-}
+}

src/main/java/com/leetcode/trees/SerializeDeserializeBinaryTree.java

@@ -0,0 +1,179 @@
+package com.leetcode.trees;
+
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Level: Hard
+ * Link: https://leetcode.com/problems/serialize-and-deserialize-binary-tree/
+ * Description:
+ * 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 tree. There is no restriction on how your
+ * serialization/deserialization algorithm should work. You just need to ensure that a binary tree can be serialized
+ * to a string and this string can be deserialized to the original tree structure.
+ *
+ * Example:
+ *
+ * You may serialize the following tree:
+ *
+ *     1
+ *    / \
+ *   2   3
+ *      / \
+ *     4   5
+ *
+ * as "[1,2,3,null,null,4,5]"
+ *
+ * Clarification: The above format is the same as how LeetCode serializes a binary tree. You do not necessarily need
+ * to follow this format, so please be creative and come up with different approaches yourself.
+ *
+ * Note: Do not use class member/global/static variables to store states. Your serialize and deserialize algorithms
+ * should be stateless.
+ *
+ * @author rampatra
+ * @since 2019-08-17
+ */
+public class SerializeDeserializeBinaryTree {
+
+    /**
+     * Runtime: <a href="https://leetcode.com/submissions/detail/252443769/">31 ms</a>.
+     *
+     * @param root
+     * @return
+     */
+    public static String serialize(TreeNode root) {
+        if (root == null) {
+            return "[]";
+        }
+
+        StringBuilder sb = new StringBuilder();
+        sb.append("[");
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+
+        while (!queue.isEmpty()) {
+            TreeNode node = queue.poll();
+
+            if (sb.length() > 1) {
+                sb.append(", ");
+            }
+            if (node == null) {
+                sb.append("null");
+                continue;
+            }
+
+            sb.append(node.val);
+
+            queue.add(node.left);
+            queue.add(node.right);
+        }
+
+        sb.append("]");
+        return removeExtraNulls(sb.toString());
+    }
+
+    private static String removeExtraNulls(String data) {
+        int i = data.length() - 1;
+        while (!(data.charAt(i) >= 48 && data.charAt(i) <= 57)) {
+            i--;
+        }
+        return data.substring(0, i + 1) + "]";
+    }
+
+    /**
+     *
+     * @param data
+     * @return
+     */
+    public static TreeNode deserialize(String data) {
+        data = data.substring(1, data.length() - 1);
+
+        if (data.length() == 0) {
+            return null;
+        }
+
+        String[] values = data.split(", ");
+
+        TreeNode root = new TreeNode(Integer.parseInt(values[0]));
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+
+        for (int i = 0; i < values.length && !queue.isEmpty(); i += 2) {
+            TreeNode currNode = queue.poll();
+
+            if (i + 1 < values.length && !values[i + 1].equals("null")) {
+                TreeNode leftNode = new TreeNode(Integer.parseInt(values[i + 1]));
+                currNode.left = leftNode;
+                queue.add(leftNode);
+            }
+
+            if (i + 2 < values.length && !values[i + 2].equals("null")) {
+                TreeNode rightNode = new TreeNode(Integer.parseInt(values[i + 2]));
+                currNode.right = rightNode;
+                queue.add(rightNode);
+            }
+        }
+
+        return root;
+    }
+
+    public static void main(String[] args) {
+        // TODO Convert the print statements to asserts
+
+        System.out.println(serialize(new TreeNode(1)));
+
+        /*
+            Binary Tree
+
+                1
+               / \
+              2   3
+             / \
+            4   5
+         */
+        TreeNode tree = new TreeNode(1);
+        tree.left = new TreeNode(2);
+        tree.right = new TreeNode(3);
+        tree.left.left = new TreeNode(4);
+        tree.left.right = new TreeNode(5);
+
+        System.out.println(serialize(tree));
+
+        System.out.println(serialize(deserialize(serialize(tree))));
+
+        System.out.println(serialize(deserialize(serialize(null))));
+
+        TreeNode tree2 = new TreeNode(1);
+        tree2.right = new TreeNode(2);
+        tree2.right.right = new TreeNode(3);
+        tree2.right.right.right = new TreeNode(4);
+        tree2.right.right.right.right = new TreeNode(5);
+        tree2.right.right.right.right.right = new TreeNode(6);
+        tree2.right.right.right.right.right.right = new TreeNode(7);
+        tree2.right.right.right.right.right.right.right = new TreeNode(8);
+
+        System.out.println(serialize(tree2));
+        System.out.println(serialize(deserialize(serialize(tree2))));
+
+        System.out.println("---");
+
+        System.out.println(serialize(deserialize("[1, 2]")));
+        System.out.println(serialize(deserialize("[1, 2, 3]")));
+        System.out.println(serialize(deserialize("[3, 2, 4, 1]")));
+        System.out.println(serialize(deserialize("[3, 2, 4, 1, 5, 6]")));
+        System.out.println(serialize(deserialize("[1, 2, 3, null, null, 4, 5]")));
+        System.out.println(serialize(deserialize("[5, 2, 3, null, null, 2, 4, 3, 1]")));
+
+        System.out.println(serialize(deserialize("[1, null, 2, null, 3, null, 4, null, 5]")));
+        System.out.println(serialize(deserialize("[1, null, 2, null, 3, null, 4, null, 5, null, 6]")));
+        System.out.println(serialize(deserialize("[1, null, 2, null, 3, null, 4, null, 5, null, 6, null, 7]")));
+        System.out.println(serialize(deserialize("[1, null, 2, null, 3, null, 4, null, 5, null, 6, null, 7, null, 8]")));
+        System.out.println(serialize(deserialize("[1, null, 2, null, 3, null, 4, null, 5, null, 6, null, 7, null, 8, null, 9]")));
+    }
+}