feat(trie): feature complete

Author: amejiarosario

src/data-structures/trees/trie-2.js

@@ -0,0 +1,133 @@
+class Trie {
+  constructor(val) {
+    this.val = val;
+    this.children = {};
+    this.isWord = false;
+  }
+
+  /**
+   * Insert word into trie and mark last element as such.
+   * @param {string} word
+   * @return {undefined}
+   */
+  insert(word) {
+    let curr = this;
+
+    for (const char of word) {
+      curr.children[char] = curr.children[char] || new Trie(char);
+      curr = curr.children[char];
+    }
+
+    curr.isWord = true;
+  }
+
+  /**
+   * Return true if found the word to be removed, otherwise false.
+   * @param {string} word - The word to remove
+   * @returns {boolean}
+   */
+  remove(word) {
+    return this.removeHelper(word);
+  }
+
+  /**
+   * Remove word from trie, return true if found, otherwise false.
+   * @param {string} word - The word to remove.
+   * @param {Trie} parent - The parent node.
+   * @param {number} index - The index.
+   * @param {number} meta.stop - Keeps track of the last letter that won't be removed.
+   * @returns {boolean}
+   */
+  removeHelper(word, parent = this, index = 0, meta = { stop: 0 }) {
+    if (index === word.length) {
+      parent.isWord = false;
+      if (Object.keys(parent.children)) { meta.stop = index; }
+      return true;
+    }
+    const child = parent.children[word.charAt(index)];
+    if (!child) { return false; }
+    if (parent.isWord) { meta.stop = index; }
+    const found = this.removeHelper(word, child, index + 1, meta);
+    // deletes all the nodes beyond `meta.stop`.
+    if (found && index >= meta.stop) {
+      delete parent.children[word.charAt(index)];
+    }
+    return found;
+  }
+
+  /**
+   * Retun last node that matches word or prefix or false if not found.
+   * @param {string} word - Word to search.
+   * @param {boolean} options.partial - Whether or not match partial matches.
+   * @return {Trie|false}
+   */
+  searchNode(word) {
+    let curr = this;
+
+    for (const char of word) {
+      if (!curr.children[char]) { return false; }
+      curr = curr.children[char];
+    }
+
+    return curr;
+  }
+
+  /**
+   * Search for complete word (by default) or partial if flag is set.
+   * @param {string} word - Word to search.
+   * @param {boolean} options.partial - Whether or not match partial matches.
+   * @return {boolean}
+   */
+  search(word, { partial } = {}) {
+    const curr = this.searchNode(word);
+    if (!curr) { return false; }
+    return partial ? true : curr.isWord;
+  }
+
+  /**
+   * Return true if any word on the trie starts with the given prefix
+   * @param {string} prefix - Partial word to search.
+   * @return {boolean}
+   */
+  startsWith(prefix) {
+    return this.search(prefix, { partial: true });
+  }
+
+  /**
+   * Returns all the words from the current `node`.
+   * Uses backtracking.
+   *
+   * @param {string} prefix - The prefix to append to each word.
+   * @param {string} node - Current node to start backtracking.
+   */
+  getAllWords(prefix = '', node = this) {
+    let words = [];
+
+    if (!node) { return words; }
+    if (node.isWord) {
+      words.push(prefix);
+    }
+
+    for (const char of Object.keys(node.children)) {
+      const newWords = this.getAllWords(`${prefix}${char}`, node.children[char]);
+      words = words.concat(newWords);
+    }
+
+    return words;
+  }
+
+  /**
+   * Return a list of words matching the prefix
+   * @param {*} prefix - The prefix to match.
+   * @returns {string[]}
+   */
+  autocomplete(prefix = '') {
+    const curr = this.searchNode(prefix);
+    return this.getAllWords(prefix, curr);
+  }
+}
+
+// Aliases
+Trie.prototype.add = Trie.prototype.insert;
+
+module.exports = Trie;

src/data-structures/trees/trie.js

@@ -27,32 +27,31 @@ class Trie {
    * @returns {boolean}
    */
   remove(word) {
-    return this.removeHelper(word);
-  }
+    let curr = this;
+    // let lastWordToKeep = 0;
+    const stack = [curr];
 
-  /**
-   * Remove word from trie, return true if found, otherwise false.
-   * @param {string} word - The word to remove.
-   * @param {Trie} parent - The parent node.
-   * @param {number} index - The index.
-   * @param {number} meta.stop - Keeps track of the last letter that won't be removed.
-   * @returns {boolean}
-   */
-  removeHelper(word, parent = this, index = 0, meta = { stop: 0 }) {
-    if (index === word.length) {
-      parent.isWord = false;
-      if (Object.keys(parent.children)) { meta.stop = index; }
-      return true;
+    // find word and stack path
+    for (const char of word) {
+      if (!curr.children[char]) { return false; }
+      // lastWordToKeep += 1;
+      curr = curr.children[char];
+      stack.push(curr);
     }
-    const child = parent.children[word.charAt(index)];
-    if (!child) { return false; }
-    if (parent.isWord) { meta.stop = index; }
-    const found = this.removeHelper(word, child, index + 1, meta);
-    // deletes all the nodes beyond `meta.stop`.
-    if (found && index >= meta.stop) {
-      delete parent.children[word.charAt(index)];
+
+    let child = stack.pop();
+    child.isWord = false;
+
+    // remove non words without children
+    while (stack.length) {
+      const parent = stack.pop();
+      if (!child.isWord && !Object.keys(child.children).length) {
+        delete parent.children[child.val];
+      }
+      child = parent;
     }
-    return found;
+
+    return true;
   }
 
   /**

src/data-structures/trees/trie.spec.js

@@ -137,7 +137,7 @@ describe('Trie', () => {
       });
     });
 
-    describe('remove', () => {
+    fdescribe('remove', () => {
       it('should remove a word', () => {
         trie = new Trie();
         trie.insert('a');

src/index.js

@@ -14,6 +14,8 @@ const BinaryTreeNode = require('./data-structures/trees/binary-tree-node');
 const AvlTree = require('./data-structures/trees/avl-tree');
 const RedBlackTree = require('./data-structures/trees/red-black-tree');
 const LRUCache = require('./data-structures/custom/lru-cache');
+const Trie = require('./data-structures/trees/trie');
+
 // algorithms
 const bubbleSort = require('./algorithms/sorting/bubble-sort');
 const insertionSort = require('./algorithms/sorting/insertion-sort');
@@ -37,6 +39,7 @@ module.exports = {
   AvlTree,
   RedBlackTree,
   LRUCache,
+  Trie,
   bubbleSort,
   insertionSort,
   selectionSort,