refactor 211

fishercoder1534 · fishercoder1534 · commit 11c64921b2af · 2018-03-13T08:30:26.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_211.java b/src/main/java/com/fishercoder/solutions/_211.java
@@ -1,6 +1,8 @@
 package com.fishercoder.solutions;
 
 /**
+ * 211. Add and Search Word - Data structure design
+ *
  * Design a data structure that supports the following two operations:
 
  void addWord(word)
@@ -22,74 +24,80 @@ bool search(word)
  You should be familiar with how a Trie works. If not, please work on this problem: Implement Trie (Prefix Tree) first.
  */
 public class _211 {
-    public class WordDictionary {
-        WordNode root = new WordNode();
+  public static class Solution1 {
+    public static class WordDictionary {
+      WordNode root;
 
-        public void addWord(String word) {
-            char[] chars = word.toCharArray();
-            addWord(chars, 0, root);
-        }
+      /** Initialize your data structure here. */
+      public WordDictionary() {
+        root = new WordNode();
+      }
 
-        private void addWord(char[] chars, int index, WordNode parent) {
-            char c = chars[index];
-            int idx = c - 'a';
-            WordNode node = parent.children[idx];
-            if (node == null) {
-                node = new WordNode();
-                parent.children[idx] = node;
-            }
-            if (chars.length == index + 1) {
-                node.isLeaf = true;
-                return;
-            }
-            addWord(chars, ++index, node);
-        }
+      public void addWord(String word) {
+        char[] chars = word.toCharArray();
+        addWord(chars, 0, root);
+      }
 
-        public boolean search(String word) {
-            return search(word.toCharArray(), 0, root);
+      private void addWord(char[] chars, int index, WordNode parent) {
+        char c = chars[index];
+        int idx = c - 'a';
+        WordNode node = parent.children[idx];
+        if (node == null) {
+          node = new WordNode();
+          parent.children[idx] = node;
+        }
+        if (chars.length == index + 1) {
+          node.isLeaf = true;
+          return;
         }
+        addWord(chars, ++index, node);
+      }
 
-        /**This is also a beautifully designed recursive function.*/
-        private boolean search(char[] chars, int index, WordNode parent) {
-            if (index == chars.length) {
-                if (parent.isLeaf) {
-                    return true;
-                }
-                return false;
-            }
-            WordNode[] childNodes = parent.children;
-            char c = chars[index];
-            if (c == '.') {
-                for (int i = 0; i < childNodes.length; i++) {
-                    WordNode n = childNodes[i];
-                    if (n != null) {
-                        boolean b = search(chars, index + 1, n);
-                        if (b) {
-                            return true;
-                        }
-                    }
-                }
-                return false;
-            }
-            WordNode node = childNodes[c - 'a'];
-            if (node == null) {
-                return false;
+      public boolean search(String word) {
+        return search(word.toCharArray(), 0, root);
+      }
+
+      /** This is also a beautifully designed recursive function. */
+      private boolean search(char[] chars, int index, WordNode parent) {
+        if (index == chars.length) {
+          if (parent.isLeaf) {
+            return true;
+          }
+          return false;
+        }
+        WordNode[] childNodes = parent.children;
+        char c = chars[index];
+        if (c == '.') {
+          for (int i = 0; i < childNodes.length; i++) {
+            WordNode n = childNodes[i];
+            if (n != null) {
+              boolean b = search(chars, index + 1, n);
+              if (b) {
+                return true;
+              }
             }
-            return search(chars, ++index, node);
+          }
+          return false;
         }
-
-        /**This is a cool/standard design for a Trie node class.*/
-        private class WordNode {
-            boolean isLeaf;
-            WordNode[] children = new WordNode[26];
+        WordNode node = childNodes[c - 'a'];
+        if (node == null) {
+          return false;
         }
+        return search(chars, ++index, node);
+      }
 
+      /** This is a cool/standard design for a Trie node class. */
+      private class WordNode {
+        boolean isLeaf;
+        WordNode[] children = new WordNode[26];
+      }
     }
 
-/**
- * Your WordDictionary object will be instantiated and called as such:
- * WordDictionary obj = new WordDictionary();
- * obj.addWord(word);
- * boolean param_2 = obj.search(word);
- */
+    /**
+     * Your WordDictionary object will be instantiated and called as such:
+     * WordDictionary obj = new WordDictionary();
+     * obj.addWord(word);
+     * boolean param_2 = obj.search(word);
+     */
+  }
 }
diff --git a/src/test/java/com/fishercoder/_211Test.java b/src/test/java/com/fishercoder/_211Test.java
@@ -0,0 +1,27 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._211;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _211Test {
+  private static _211.Solution1.WordDictionary wordDictionarySolution1;
+
+  @BeforeClass
+  public static void setup() {
+    wordDictionarySolution1 = new _211.Solution1.WordDictionary();
+  }
+
+  @Test
+  public void test1() {
+    wordDictionarySolution1.addWord("bad");
+    wordDictionarySolution1.addWord("dad");
+    wordDictionarySolution1.addWord("mad");
+    assertEquals(false, wordDictionarySolution1.search("pad"));
+    assertEquals(true, wordDictionarySolution1.search("bad"));
+    assertEquals(true, wordDictionarySolution1.search(".ad"));
+    assertEquals(true, wordDictionarySolution1.search("b.."));
+  }
+}
