chapter 12: tries

Author: loiane

src/12-trie/01-spell-checker.js

@@ -0,0 +1,53 @@
+// src/12-trie/01-spell-checker.js
+
+const Trie = require('./trie');
+
+class SpellChecker {
+  #trie = new Trie();
+
+  buildDictionary(words) {
+    for (let word of words) {
+      this.#trie.insert(word);
+    }
+  }
+
+  isWordInDictionary(word) {
+    return this.#trie.search(word);
+  }
+
+  getSuggestions(word) {
+    const suggestions = [];
+    const wordArray = word.split('');
+    for (let i = 0; i < wordArray.length; i++) {
+      const temp = wordArray[i];
+      wordArray[i] = '';
+      const newWord = wordArray.join('');
+      if (this.#trie.startsWith(newWord)) {
+        suggestions.push(newWord);
+      }
+      wordArray[i] = temp;
+    }
+    return suggestions;
+  }
+
+  removeWord(word) {
+    return this.#trie.remove(word);
+  }
+}
+
+const spellChecker = new SpellChecker();
+spellChecker.buildDictionary(['cat', 'bat', 'rat', 'drat', 'dart', 'date']);
+console.log(spellChecker.isWordInDictionary('bat')); // true
+console.log(spellChecker.isWordInDictionary('drate')); // false
+console.log(spellChecker.getSuggestions('drate')); // [ 'date', 'drat' ]
+
+
+const trie = new Trie();
+trie.insert('she');
+trie.insert('sells');
+trie.insert('sea');
+trie.insert('shells');
+trie.insert('by');
+trie.insert('the');
+
+// to see the output of this file use the command: node src/12-trie/01-spell-checker.js

src/12-trie/leetcode/design-add-and-search-words-data-structure.ts

@@ -0,0 +1,54 @@
+// https://leetcode.com/problems/design-add-and-search-words-data-structure/description/
+// 211. Design Add and Search Words Data Structure
+
+// @ts-ignore
+class TrieNode {
+    children: Map<string, TrieNode>;
+    isEndOfWord: boolean;
+
+    constructor() {
+        this.children = new Map<string, TrieNode>();
+        this.isEndOfWord = false;
+    }
+}
+
+class WordDictionary {
+    private root: TrieNode;
+
+    constructor() {
+        this.root = new TrieNode();
+    }
+
+    addWord(word: string): void {
+        let node = this.root;
+        for (let char of word) {
+            if (!node.children.has(char)) {
+                node.children.set(char, new TrieNode());
+            }
+            node = node.children.get(char)!;
+        }
+        node.isEndOfWord = true;
+    }
+
+    search(word: string): boolean {
+        return this.searchFromNode(word, this.root);
+    }
+
+    private searchFromNode(word: string, node: TrieNode): boolean {
+        for (let i = 0; i < word.length; i++) {
+            const char = word[i];
+            if (char === '.') {
+                for (let child of node.children.values()) {
+                    if (this.searchFromNode(word.slice(i + 1), child)) {
+                        return true;
+                    }
+                }
+                return false;
+            } else if (!node.children.has(char)) {
+                return false;
+            }
+            node = node.children.get(char)!;
+        }
+        return node.isEndOfWord;
+    }
+}

src/12-trie/leetcode/implement-trie-prefix-tree.ts

@@ -0,0 +1,62 @@
+// https://leetcode.com/problems/implement-trie-prefix-tree/
+// 208. Implement Trie (Prefix Tree)
+
+
+class TrieNode {
+  children: Map<string, TrieNode>;
+  isEndOfWord: boolean;
+
+  constructor() {
+    this.children = new Map<string, TrieNode>();
+    this.isEndOfWord = false;
+  }
+}
+
+class Trie {
+  private root: TrieNode;
+
+  constructor() {
+    this.root = new TrieNode();
+  }
+
+  insert(word: string): void {
+    let node = this.root;
+    for (let char of word) {
+      if (!node.children.has(char)) {
+        node.children.set(char, new TrieNode());
+      }
+      node = node.children.get(char)!;
+    }
+    node.isEndOfWord = true;
+  }
+
+  search(word: string): boolean {
+    let node = this.root;
+    for (let char of word) {
+      if (!node.children.has(char)) {
+        return false;
+      }
+      node = node.children.get(char)!;
+    }
+    return node.isEndOfWord;
+  }
+
+  startsWith(prefix: string): boolean {
+    let node = this.root;
+    for (let char of prefix) {
+      if (!node.children.has(char)) {
+        return false;
+      }
+      node = node.children.get(char)!;
+    }
+    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)
+ */

src/12-trie/leetcode/longest-common-prefix.ts

@@ -0,0 +1,66 @@
+// https://leetcode.com/problems/longest-common-prefix/description/
+// 14. Longest Common Prefix
+
+function longestCommonPrefix(strs: string[]): string {
+  if (strs.length === 0) { return ''; }
+  let prefix = strs[0];
+  for (let i = 1; i < strs.length; i++) {
+    while (strs[i].indexOf(prefix) !== 0) {
+      prefix = prefix.substring(0, prefix.length - 1);
+    }
+  }
+  return prefix;
+}
+
+// @ts-ignore
+class TrieNode {
+  children: Map<string, TrieNodeMap> = new Map();
+  isEndOfWord: boolean = false;
+}
+
+// @ts-ignore
+class Trie {
+  private root: TrieNode;
+
+  constructor() {
+    this.root = new TrieNode();
+  }
+
+  insert(word: string): void {
+    let node = this.root;
+    for (let char of word) {
+      if (!node.children.has(char)) {
+        node.children.set(char, new TrieNode());
+      }
+      node = node.children.get(char);
+    }
+    node.isEndOfWord = true;
+  }
+
+  findLongestCommonPrefix(): string {
+    let node = this.root;
+    let prefix = '';
+    while (node.children.size === 1 && !node.isEndOfWord) {
+      const char = Array.from(node.children.keys())[0];
+      prefix += char;
+      node = node.children.get(char);
+    }
+    return prefix;
+  }
+}
+
+function longestCommonPrefixTrie(strs: string[]): string {
+  if (strs.length === 0) {
+    return '';
+  }
+
+  let trie = new Trie();
+  for (let str of strs) {
+    trie.insert(str);
+  }
+
+  return trie.findLongestCommonPrefix();
+}
+
+console.log(longestCommonPrefix(['flower', 'flow', 'flight'])); // 'fl'
+console.log(longestCommonPrefix(['dog', 'racecar', 'car'])); // ''

src/12-trie/trie.js

@@ -0,0 +1,70 @@
+class TrieNode {
+  constructor() {
+    this.children = new Map();
+    this.isEndOfWord = false;
+  }
+}
+
+class Trie {
+  #root = new TrieNode();
+
+  insert(word) {
+    let node = this.#root;
+    for (let char of word) {
+      if (!node.children.has(char)) {
+        node.children.set(char, new TrieNode());
+      }
+      node = node.children.get(char);
+    }
+    node.isEndOfWord = true;
+  }
+
+  search(word) {
+    let node = this.#root;
+    for (let char of word) {
+      if (!node.children.has(char)) {
+        return false;
+      }
+      node = node.children.get(char);
+    }
+    return node.isEndOfWord;
+  }
+
+  startsWith(prefix) {
+    let node = this.#root;
+    for (let char of prefix) {
+      if (!node.children.has(char)) {
+        return false;
+      }
+      node = node.children.get(char);
+    }
+    return true;
+  }
+
+  remove(word) {
+    return this.#removeWord(this.#root, word, 0);
+  }
+
+  #removeWord(node, word, index) {
+    if (index === word.length) {
+      if (!node.isEndOfWord) return false;
+      node.isEndOfWord = false;
+      return node.children.size === 0;
+    }
+
+    const char = word[index];
+    if (!node.children.has(char)) {
+      return false;
+    }
+
+    const shouldDeleteCurrentNode = this.#removeWord(node.children.get(char), word, index + 1);
+    if (shouldDeleteCurrentNode) {
+      node.children.delete(char);
+      return node.children.size === 0;
+    }
+
+    return false;
+  }
+}
+
+module.exports = Trie;

src/12-trie/trie.ts

@@ -0,0 +1,77 @@
+class TrieNode {
+  children: Map<string, TrieNode>;
+  isEndOfWord: boolean;
+
+  constructor() {
+    this.children = new Map<string, TrieNode>();
+    this.isEndOfWord = false;
+  }
+}
+
+class Trie {
+  private root: TrieNode;
+
+  constructor() {
+    this.root = new TrieNode();
+  }
+
+  insert(word: string): void {
+    let node = this.root;
+    for (let char of word) {
+      if (!node.children.has(char)) {
+        node.children.set(char, new TrieNode());
+      }
+      node = node.children.get(char)!;
+    }
+    node.isEndOfWord = true;
+  }
+
+  search(word: string): boolean {
+    let node = this.root;
+    for (let char of word) {
+      if (!node.children.has(char)) {
+        return false;
+      }
+      node = node.children.get(char)!;
+    }
+    return node.isEndOfWord;
+  }
+
+  startsWith(prefix: string): boolean {
+    let node = this.root;
+    for (let char of prefix) {
+      if (!node.children.has(char)) {
+        return false;
+      }
+      node = node.children.get(char)!;
+    }
+    return true;
+  }
+
+  remove(word: string): boolean {
+    return this.#removeWord(this.root, word, 0);
+  }
+
+  #removeWord(node: TrieNode, word: string, index: number): boolean {
+    if (index === word.length) {
+      if (!node.isEndOfWord) return false;
+      node.isEndOfWord = false;
+      return node.children.size === 0;
+    }
+
+    const char = word[index];
+    if (!node.children.has(char)) {
+      return false;
+    }
+
+    const shouldDeleteCurrentNode = this.#removeWord(node.children.get(char)!, word, index + 1);
+    if (shouldDeleteCurrentNode) {
+      node.children.delete(char);
+      return node.children.size === 0;
+    }
+
+    return false;
+  }
+}
+
+export default Trie;