Implement suffix (reversed) trie

Build/lib/trie.js

@@ -0,0 +1,300 @@
+/**
+ * Suffix Trie based on Mnemonist Trie
+ */
+
+const SENTINEL = String.fromCharCode(0);
+
+class Trie {
+  size = 0;
+  root = {};
+
+  /**
+   * Method used to add the given prefix to the trie.
+   *
+   * @param  {string} suffix - Prefix to follow.
+   * @return {Trie}
+   */
+  add(suffix) {
+    let node = this.root;
+    let token;
+
+    for (let i = suffix.length - 1; i >= 0; i--) {
+      token = suffix[i];
+
+      node = node[token] || (node[token] = {});
+    }
+
+    // Do we need to increase size?
+    if (!(SENTINEL in node)) this.size++;
+    node[SENTINEL] = true;
+
+    return this;
+  }
+
+  /**
+   * Method used to retrieve every item in the trie with the given prefix.
+   *
+   * @param  {string} suffix - Prefix to query.
+   * @param  {boolean} [includeEqualWithSuffix]
+   * @return {string[]}
+   */
+  find(suffix, includeEqualWithSuffix = true) {
+    let node = this.root;
+    const matches = [];
+    let token;
+    let i;
+    let l;
+
+    for (let i = suffix.length - 1; i >= 0; i--) {
+      token = suffix[i];
+
+      node = node[token];
+
+      if (node == null) return matches;
+    }
+
+    // Performing DFS from prefix
+    const nodeStack = [node];
+
+    const suffixStack = [suffix];
+    let k;
+
+    let $suffix = suffix;
+
+    while (nodeStack.length) {
+      $suffix = suffixStack.pop();
+      node = nodeStack.pop();
+
+      for (k in node) {
+        if (k === SENTINEL) {
+          if (includeEqualWithSuffix) {
+            matches.push($suffix);
+          } else if ($suffix !== suffix) {
+            matches.push($suffix);
+          }
+
+
+          continue;
+        }
+
+        nodeStack.push(node[k]);
+        suffixStack.push(k + $suffix);
+      }
+    }
+
+    return matches;
+  }
+
+  toJSON() {
+    return this.root;
+  }
+
+  /**
+   * Method used to clear the trie.
+   *
+   * @return {void}
+   */
+  // clear() {
+  //   // Properties
+  //   this.root = {};
+  //   this.size = 0;
+  // }
+
+  /**
+   * Method used to update the value of the given prefix in the trie.
+   *
+   * @param  {string|array} prefix - Prefix to follow.
+   * @param  {(oldValue: any | undefined) => any} updateFunction - Update value visitor callback.
+   * @return {Trie}
+   */
+  // update(prefix, updateFunction) {
+  //   let node = this.root;
+  //   let token;
+
+  //   for (let i = 0, l = prefix.length; i < l; i++) {
+  //     token = prefix[i];
+
+  //     node = node[token] || (node[token] = {});
+  //   }
+
+  //   // Do we need to increase size?
+  //   if (!(SENTINEL in node))
+  //     this.size++;
+
+  //   node[SENTINEL] = updateFunction(node[SENTINEL]);
+
+  //   return this;
+  // }
+
+  /**
+   * Method used to delete a prefix from the trie.
+   *
+   * @param  {string|array} suffix - Prefix to delete.
+   * @return {boolean}
+   */
+  delete(suffix) {
+    let node = this.root;
+    let toPrune = null;
+    let tokenToPrune = null;
+    let parent;
+    let token;
+
+    for (let i = suffix.length - 1; i >= 0; i--) {
+      token = suffix[i];
+      parent = node;
+      node = node[token];
+
+      // Prefix does not exist
+      if (typeof node === 'undefined')
+        return false;
+
+      // Keeping track of a potential branch to prune
+      if (toPrune !== null) {
+        if (Object.keys(node).length > 1) {
+          toPrune = null;
+          tokenToPrune = null;
+        }
+      }
+      else {
+        if (Object.keys(node).length < 2) {
+          toPrune = parent;
+          tokenToPrune = token;
+        }
+      }
+    }
+
+    if (!(SENTINEL in node)) return false;
+
+    this.size--;
+
+    if (toPrune) {
+      delete toPrune[tokenToPrune];
+    } else {
+      delete node[SENTINEL];
+    }
+
+    return true;
+  }
+
+  /**
+   * Method used to assert whether the given prefix exists in the Trie.
+   *
+   * @param  {string} suffix - Prefix to check.
+   * @return {boolean}
+   */
+  has(suffix) {
+    let node = this.root;
+    let token;
+
+    for (let i = suffix.length - 1; i >= 0; i--) {
+      token = suffix[i];
+      node = node[token];
+
+      if (typeof node === 'undefined')
+        return false;
+    }
+
+    return SENTINEL in node;
+  }
+
+  /**
+   * Method returning an iterator over the trie's prefixes.
+   *
+   * @param  {string|array} [prefix] - Optional starting prefix.
+   * @return {Iterator}
+   */
+  // prefixes(prefix) {
+  //   let node = this.root;
+  //   const nodeStack = [];
+  //   const prefixStack = [];
+  //   let token;
+  //   let i;
+  //   let l;
+
+  //   const isString = this.mode === 'string';
+
+  //   // Resolving initial prefix
+  //   if (prefix) {
+  //     for (i = 0, l = prefix.length; i < l; i++) {
+  //       token = prefix[i];
+  //       node = node[token];
+
+  //       // If the prefix does not exist, we return an empty iterator
+  //       if (typeof node === 'undefined')
+  //         return Iterator.empty();
+  //     }
+  //   }
+  //   else {
+  //     prefix = isString ? '' : [];
+  //   }
+
+  //   nodeStack.push(node);
+  //   prefixStack.push(prefix);
+
+  //   return new Iterator(() => {
+  //     let currentNode;
+  //     let currentPrefix;
+  //     let hasValue = false;
+  //     let k;
+
+  //     while (nodeStack.length) {
+  //       currentNode = nodeStack.pop();
+  //       currentPrefix = prefixStack.pop();
+
+  //       for (k in currentNode) {
+  //         if (k === SENTINEL) {
+  //           hasValue = true;
+  //           continue;
+  //         }
+
+  //         nodeStack.push(currentNode[k]);
+  //         prefixStack.push(isString ? currentPrefix + k : currentPrefix.concat(k));
+  //       }
+
+  //       if (hasValue)
+  //         return { done: false, value: currentPrefix };
+  //     }
+
+  //     return { done: true };
+  //   });
+  // }
+
+  /**
+   * Convenience known methods.
+   */
+  // inspect() {
+  //   const proxy = new Set();
+
+  //   const iterator = this.prefixes();
+  //   let step;
+
+  //   while ((step = iterator.next(), !step.done))
+  //     proxy.add(step.value);
+
+  //   // Trick so that node displays the name of the constructor
+  //   Object.defineProperty(proxy, 'constructor', {
+  //     value: Trie,
+  //     enumerable: false
+  //   });
+
+  //   return proxy;
+  // }
+  /**
+   * Static .from function taking an arbitrary iterable & converting it into
+   * a trie.
+   *
+   * @param  {string[]} iterable   - Target iterable.
+   * @return {Trie}
+   */
+  static from = iterable => {
+    const trie = new Trie();
+    iterable.forEach(i => trie.add(i));
+    return trie;
+  };
+}
+
+/**
+ * Exporting.
+ */
+module.exports.SENTINEL = SENTINEL;
+module.exports = Trie;