Merge pull request #447 from aakhtar3/trie

refactor: js - trie

Author: Ahmad-A0

javascript/208-Implement-Trie.js

@@ -1,50 +1,59 @@
-class TrieNode {
-  constructor() {
-    this.children = {};
-    this.endOfWord = false;
-  }
-}
-
-class Trie {
-  constructor() {
-    this.root = new TrieNode();
-  }
-
-  insert(word) {
-    let cur = this.root;
-
-    for (const c of word) {
-      if (!(c in cur.children)) {
-        cur.children[c] = new TrieNode();
-      }
-      cur = cur.children[c];
-    }
-    cur.endOfWord = true;
-  }
-
-  search(word) {
-    let cur = this.root;
-
-    for (const c of word) {
-      if (!(c in cur.children)) {
-        return false;
-      }
-      cur = cur.children[c];
-    }
-
-    return cur.endOfWord;
-  }
-
-  startsWith(prefix) {
-    let cur = this.root;
-
-    for (const c of prefix) {
-      if (!(c in cur.children)) {
-        return false;
-      }
-      cur = cur.children[c];
-    }
-
-    return true;
-  }
-}
+/** 
+ * Your Trie object will be instantiated and called as such:
+ * var obj = new Trie()
+ * obj.insert(word)
+ * var param_2 = obj.search(word)
+ * var param_3 = obj.startsWith(prefix)
+ */
+
+class TrieNode {
+    constructor() {
+        this.children = {};
+        this.isWord = false;
+    }
+}
+
+class Trie {
+    constructor () {
+        this.root = new TrieNode();
+    }
+
+    /* Time O(N) | Space O(N) */
+    insert (word, node = this.root) {
+        for (const char of word) {
+            const child = node.children[char] || new TrieNode();
+
+            node.children[char] = child;
+
+            node = child;
+        }
+
+        node.isWord = true;
+    }
+
+    /* Time O(N) | Space O(1) */
+    search (word, node = this.root) {
+        for (const char of word) {
+            const child = node.children[char] || null;
+
+            if (!child) return false;
+
+            node = child;
+        }
+
+        return node.isWord;
+    }
+
+    /* Time O(N) | Space O(1) */
+    startsWith (prefix, node = this.root) {
+        for (const char of prefix) {
+            const child = node.children[char] || null;
+
+            if (!child) return false;
+
+            node = child;
+        }
+
+        return true;
+    }
+};

javascript/211-Design-Add-and-Search-Words-Data-Structure.js

@@ -1,55 +1,60 @@
-class TrieNode {
-  constructor() {
-    this.children = {};
-    this.endOfWord = false;
-  }
-}
-
-class WordDictionary {
-  constructor() {
-    this.root = new TrieNode();
-  }
-
-  addWord(word) {
-    let cur = this.root;
-
-    for (const c of word) {
-      if (!(c in cur.children)) {
-        cur.children[c] = new TrieNode();
-      }
-      cur = cur.children[c];
-    }
-    cur.endOfWord = true;
-  }
-
-  search(word) {
-    function dfs(j, root) {
-      let cur = root;
-
-      for (let i = j; i < word.length; i++) {
-        const c = word[i];
-
-        if (c === ".") {
-          for (const key in cur.children) {
-            if (Object.prototype.hasOwnProperty.call(cur.children, key)) {
-              const child = cur.children[key];
-
-              if (dfs(i + 1, child)) {
-                return true;
-              }
-            }
-          }
-          return false;
-        } else {
-          if (!(c in cur.children)) {
-            return false;
-          }
-          cur = cur.children[c];
-        }
-      }
-
-      return cur.endOfWord;
-    }
-    return dfs(0, this.root);
-  }
-}
+/** 
+ * Your WordDictionary object will be instantiated and called as such:
+ * var obj = new WordDictionary()
+ * obj.addWord(word)
+ * var param_2 = obj.search(word)
+ */
+
+ class TrieNode {
+    constructor() {
+        this.children = {};
+        this.isWord = false;
+    }
+};
+
+class WordDictionary {
+    constructor() {
+        this.root = new TrieNode();
+    }
+
+    /* Time O(N) | Space O(N) */
+    addWord (word, node = this.root) {
+        for (const char of word) {
+            const child = node.children[char] || new TrieNode();
+
+            node.children[char] = child;
+
+            node = child;
+        }
+
+        node.isWord = true;
+    }
+
+    /* Time O(N) | Space O(N) */
+    search (word) {
+        return this.dfs(word, this.root, 0);
+    }
+
+    dfs (word, node, level) {
+        if (!node) return false;
+
+        const isWord = level === word.length;
+        if (isWord) return node.isWord;
+
+        const isWildCard = word[level] === '.';
+        if (isWildCard) return this.hasWildCard(word, node, level);
+
+        return this.dfs(word, node.children[word[level]], (level + 1));
+    }
+
+    hasWildCard (word, node, level) {
+        for (const char of Object.keys(node.children)) {
+            const child = node.children[char];
+
+            const hasWord = this.dfs(word, child, (level + 1));
+            if (hasWord) return true;
+        }
+
+        return false;
+    }
+}

javascript/212-Word-Search-ii.js

@@ -0,0 +1,103 @@
+/**
+ * @param {character[][]} board
+ * @param {string[]} words
+ * Time O((ROWS * COLS) * (4 * (3 ^ (WORDS - 1)))) | Space O(N)
+ * @return {string[]}
+ */
+ var findWords = function(board, words) {
+    return new Trie(words).searchBoard(board);
+}
+
+class TrieNode {
+    constructor() {
+        this.children = {};
+        this.word = '';
+    }
+}
+
+class Trie {
+    constructor(words) {
+        this.root = new TrieNode();
+        words.forEach((word) => this.insert(word));
+    }
+
+    /* Time O(N) | Space O(N) */
+    insert (word, node = this.root) {
+        for (const char of word) {
+            const child = node.children[char] || new TrieNode();
+
+            node.children[char] = child;
+
+            node = child;
+        }
+
+        node.word = word;
+    }
+
+    /* Time O((ROWS * COLS) * (4 * (3 ^ (WORDS - 1)))) | Space O(N) */
+    searchBoard (board, node = this.root, words = []) {
+        const [ rows, cols ] = [ board.length, board[0].length ];
+        
+        for (let row = 0; row < rows; row++) {
+            for (let col = 0; col < cols; col++) {
+                this.dfs(board, row, rows, col, cols, node, words);
+            }
+        }
+
+        return words;
+    }
+
+    dfs (board, row, rows, col, cols, node, words) {
+        const char = board[row][col];
+        const child = node.children[char] || null;
+
+        if (this.canSkip(char, child)) return;
+    
+        node = child;
+        this.checkWord(node, words);
+        this.backTrack(board, row, rows, col, cols, node, words);
+    }
+    
+    
+    canSkip (char, child) {
+        const hasSeen = char === '#';
+        const isMissingChild = !child;
+        
+        return hasSeen || isMissingChild;
+    }
+    
+    checkWord (node, words) {
+        if (!node.word.length) return;
+
+        words.push(node.word);
+        node.word = '';
+    }
+    
+    backTrack (board, row, rows, col, cols, node, words) {
+        const char = board[row][col];
+        
+        board[row][col] = '#';
+
+        for (const [ _row, _col ] of this.getNeighbors(row, rows, col, cols)) {
+            this.dfs(board, _row, rows, _col, cols, node, words);
+        }
+
+        board[row][col] = char;
+    }
+    
+    getNeighbors (row, rows, col, cols) {
+        return [
+            [row - 1, col],
+            [row + 1, col],
+            [row, col - 1],
+            [row, col + 1]
+        ].filter(([ _row, _col ]) => !this.isOutOfBounds(_row, rows, _col, cols));
+    }
+
+    isOutOfBounds(row, rows, col, cols) {
+        const isRowOut = row < 0 || rows <= row;
+        const isColOut = col < 0 || cols <= col;
+
+        return isRowOut || isColOut;
+    }
+}