min-heap-typed 1.50.1 → 1.50.3

package/src/data-structures/trie/trie.ts

@@ -13,14 +13,70 @@ import { IterableElementBase } from '../base';
  * and a flag indicating whether it's the end of a word.
  */
 export class TrieNode {
-  key: string;
-  children: Map<string, TrieNode>;
-  isEnd: boolean;
-
   constructor(key: string) {
-    this.key = key;
-    this.isEnd = false;
-    this.children = new Map<string, TrieNode>();
+    this._key = key;
+    this._isEnd = false;
+    this._children = new Map<string, TrieNode>();
+  }
+
+  protected _key: string;
+
+  /**
+   * The function returns the value of the protected variable _key.
+   * @returns The value of the `_key` property, which is a string.
+   */
+  get key(): string {
+    return this._key;
+  }
+
+  /**
+   * The above function sets the value of a protected variable called "key".
+   * @param {string} value - The value parameter is a string that represents the value to be assigned
+   * to the key.
+   */
+  set key(value: string) {
+    this._key = value;
+  }
+
+  protected _children: Map<string, TrieNode>;
+
+  /**
+   * The function returns the children of a TrieNode as a Map.
+   * @returns The `children` property of the TrieNode object, which is a Map containing string keys and
+   * TrieNode values.
+   */
+  get children(): Map<string, TrieNode> {
+    return this._children;
+  }
+
+  /**
+   * The function sets the value of the `_children` property of a TrieNode object.
+   * @param value - The value parameter is a Map object that represents the children of a TrieNode. The
+   * keys of the map are strings, which represent the characters that are associated with each child
+   * TrieNode. The values of the map are TrieNode objects, which represent the child nodes of the
+   * current TrieNode.
+   */
+  set children(value: Map<string, TrieNode>) {
+    this._children = value;
+  }
+
+  protected _isEnd: boolean;
+
+  /**
+   * The function returns a boolean value indicating whether a certain condition is met.
+   * @returns The method is returning a boolean value, specifically the value of the variable `_isEnd`.
+   */
+  get isEnd(): boolean {
+    return this._isEnd;
+  }
+
+  /**
+   * The function sets the value of the "_isEnd" property.
+   * @param {boolean} value - The value parameter is a boolean value that indicates whether the current
+   * state is the end state or not.
+   */
+  set isEnd(value: boolean) {
+    this._isEnd = value;
   }
 }
 
@@ -37,7 +93,13 @@ export class TrieNode {
  * 10. IP Routing: Used in certain types of IP routing algorithms.
  * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data."
  */
-export class Trie extends IterableElementBase<string> {
+export class Trie extends IterableElementBase<string, Trie> {
+  /**
+   * The constructor function for the Trie class.
+   * @param words: Iterable string Initialize the trie with a set of words
+   * @param options?: TrieOptions Allow the user to pass in options for the trie
+   * @return This
+   */
   constructor(words: Iterable<string> = [], options?: TrieOptions) {
     super();
     if (options) {
@@ -51,30 +113,42 @@ export class Trie extends IterableElementBase<string> {
 
   protected _size: number = 0;
 
+  /**
+   * The size function returns the size of the stack.
+   * @return The number of elements in the list
+   */
   get size(): number {
     return this._size;
   }
 
   protected _caseSensitive: boolean = true;
 
+  /**
+   * The caseSensitive function is a getter that returns the value of the protected _caseSensitive property.
+   * @return The value of the _caseSensitive protected variable
+   */
   get caseSensitive(): boolean {
     return this._caseSensitive;
   }
 
   protected _root: TrieNode = new TrieNode('');
 
+  /**
+   * The root function returns the root node of the tree.
+   * @return The root node
+   */
   get root() {
     return this._root;
   }
 
   /**
-   * Time Complexity: O(M), where M is the length of the word being added.
-   * Space Complexity: O(M) - Each character in the word adds a TrieNode.
+   * Time Complexity: O(l), where l is the length of the word being added.
+   * Space Complexity: O(l) - Each character in the word adds a TrieNode.
    */
 
   /**
-   * Time Complexity: O(M), where M is the length of the word being added.
-   * Space Complexity: O(M) - Each character in the word adds a TrieNode.
+   * Time Complexity: O(l), where l is the length of the word being added.
+   * Space Complexity: O(l) - Each character in the word adds a TrieNode.
    *
    * Add a word to the Trie structure.
    * @param {string} word - The word to add.
@@ -101,12 +175,12 @@ export class Trie extends IterableElementBase<string> {
   }
 
   /**
-   * Time Complexity: O(M), where M is the length of the input word.
+   * Time Complexity: O(l), where l is the length of the input word.
    * Space Complexity: O(1) - Constant space.
    */
 
   /**
-   * Time Complexity: O(M), where M is the length of the input word.
+   * Time Complexity: O(l), where l is the length of the input word.
    * Space Complexity: O(1) - Constant space.
    *
    * Check if the Trie contains a given word.
@@ -125,13 +199,45 @@ export class Trie extends IterableElementBase<string> {
   }
 
   /**
-   * Time Complexity: O(M), where M is the length of the word being deleted.
-   * Space Complexity: O(M) - Due to the recursive DFS approach.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The isEmpty function checks if the size of the queue is 0.
+   * @return True if the size of the queue is 0
+   */
+  isEmpty(): boolean {
+    return this.size === 0;
+  }
+
+  /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(M), where M is the length of the word being deleted.
-   * Space Complexity: O(M) - Due to the recursive DFS approach.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The clear function resets the size of the Trie to 0 and creates a new root TrieNode.
+   */
+  clear(): void {
+    this._size = 0;
+    this._root = new TrieNode('');
+  }
+
+  /**
+   * Time Complexity: O(l), where l is the length of the word being deleted.
+   * Space Complexity: O(n) - Due to the recursive DFS approach.
+   */
+
+  /**
+   * Time Complexity: O(l), where l is the length of the word being deleted.
+   * Space Complexity: O(n) - Due to the recursive DFS approach.
    *
    * Remove a word from the Trie structure.
    * @param{string} word - The word to delete.
@@ -174,12 +280,12 @@ export class Trie extends IterableElementBase<string> {
   }
 
   /**
-   * Time Complexity: O(N), where N is the total number of nodes in the trie.
+   * Time Complexity: O(n), where n is the total number of nodes in the trie.
    * Space Complexity: O(1) - Constant space.
    */
 
   /**
-   * Time Complexity: O(N), where N is the total number of nodes in the trie.
+   * Time Complexity: O(n), where n is the total number of nodes in the trie.
    * Space Complexity: O(1) - Constant space.
    *
    */
@@ -204,12 +310,12 @@ export class Trie extends IterableElementBase<string> {
   }
 
   /**
-   * Time Complexity: O(M), where M is the length of the input prefix.
+   * Time Complexity: O(l), where l is the length of the input prefix.
    * Space Complexity: O(1) - Constant space.
    */
 
   /**
-   * Time Complexity: O(M), where M is the length of the input prefix.
+   * Time Complexity: O(l), where l is the length of the input prefix.
    * Space Complexity: O(1) - Constant space.
    *
    * Check if a given input string has an absolute prefix in the Trie, meaning it's not a complete word.
@@ -228,12 +334,12 @@ export class Trie extends IterableElementBase<string> {
   }
 
   /**
-   * Time Complexity: O(M), where M is the length of the input prefix.
+   * Time Complexity: O(l), where l is the length of the input prefix.
    * Space Complexity: O(1) - Constant space.
    */
 
   /**
-   * Time Complexity: O(M), where M is the length of the input prefix.
+   * Time Complexity: O(l), where l is the length of the input prefix.
    * Space Complexity: O(1) - Constant space.
    *
    * Check if a given input string is a prefix of any existing word in the Trie, whether as an absolute prefix or a complete word.
@@ -252,13 +358,13 @@ export class Trie extends IterableElementBase<string> {
   }
 
   /**
-   * Time Complexity: O(N), where N is the total number of nodes in the trie.
-   * Space Complexity: O(M), where M is the length of the input prefix.
+   * Time Complexity: O(n), where n is the total number of nodes in the trie.
+   * Space Complexity: O(l), where l is the length of the input prefix.
    */
 
   /**
-   * Time Complexity: O(N), where N is the total number of nodes in the trie.
-   * Space Complexity: O(M), where M is the length of the input prefix.
+   * Time Complexity: O(n), where n is the total number of nodes in the trie.
+   * Space Complexity: O(l), where l is the length of the input prefix.
    *
    * Check if the input string is a common prefix in the Trie, meaning it's a prefix shared by all words in the Trie.
    * @param {string} input - The input string representing the common prefix to check for.
@@ -279,13 +385,13 @@ export class Trie extends IterableElementBase<string> {
   }
 
   /**
-   * Time Complexity: O(N), where N is the total number of nodes in the trie.
-   * Space Complexity: O(M), where M is the length of the longest common prefix.
+   * Time Complexity: O(n), where n is the total number of nodes in the trie.
+   * Space Complexity: O(l), where l is the length of the longest common prefix.
    */
 
   /**
-   * Time Complexity: O(N), where N is the total number of nodes in the trie.
-   * Space Complexity: O(M), where M is the length of the longest common prefix.
+   * Time Complexity: O(n), where n is the total number of nodes in the trie.
+   * Space Complexity: O(l), where l is the length of the longest common prefix.
    *
    * Get the longest common prefix among all the words stored in the Trie.
    * @returns {string} The longest common prefix found in the Trie.
@@ -303,13 +409,13 @@ export class Trie extends IterableElementBase<string> {
   }
 
   /**
-   * Time Complexity: O(K * L), where K is the number of words retrieved, and L is the average length of the words.
-   * Space Complexity: O(K * L) - The space required for the output array.
+   * Time Complexity: O(w * l), where w is the number of words retrieved, and l is the average length of the words.
+   * Space Complexity: O(w * l) - The space required for the output array.
    */
 
   /**
-   * Time Complexity: O(K * L), where K is the number of words retrieved, and L is the average length of the words.
-   * Space Complexity: O(K * L) - The space required for the output array.
+   * Time Complexity: O(w * l), where w is the number of words retrieved, and l is the average length of the words.
+   * Space Complexity: O(w * l) - The space required for the output array.
    *
    * The `getAll` function returns an array of all words in a Trie data structure that start with a given prefix.
    * @param {string} prefix - The `prefix` parameter is a string that represents the prefix that we want to search for in the
@@ -351,6 +457,23 @@ export class Trie extends IterableElementBase<string> {
     return words;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `clone` function returns a new instance of the Trie class with the same values and case
+   * sensitivity as the original Trie.
+   * @returns A new instance of the Trie class is being returned.
+   */
+  clone(): Trie {
+    return new Trie(this.values(), { caseSensitive: this.caseSensitive });
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -410,6 +533,18 @@ export class Trie extends IterableElementBase<string> {
     return newTrie;
   }
 
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The function `_getIterator` returns an iterable iterator that performs a depth-first search on a
+   * trie data structure and yields all the paths to the end nodes.
+   */
   protected* _getIterator(): IterableIterator<string> {
     function* _dfs(node: TrieNode, path: string): IterableIterator<string> {
       if (node.isEnd) {
@@ -424,12 +559,12 @@ export class Trie extends IterableElementBase<string> {
   }
 
   /**
-   * Time Complexity: O(M), where M is the length of the input string.
+   * Time Complexity: O(l), where l is the length of the input string.
    * Space Complexity: O(1) - Constant space.
    */
 
   /**
-   * Time Complexity: O(M), where M is the length of the input string.
+   * Time Complexity: O(l), where l is the length of the input string.
    * Space Complexity: O(1) - Constant space.
    *
    * @param str

package/src/types/data-structures/binary-tree/binary-tree.ts

@@ -3,7 +3,7 @@ import { IterationType } from "../../common";
 
 export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type BinaryTreeNested<K, V, N extends BinaryTreeNode<K, V, N>> = BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
+export type BinaryTreeNested<K, V, NODE extends BinaryTreeNode<K, V, NODE>> = BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, BinaryTree<K, V, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
 export type BinaryTreeOptions<K> = {
   iterationType?: IterationType,

package/src/types/data-structures/hash/hash-map.ts

@@ -5,14 +5,15 @@ export type HashMapLinkedNode<K, V> = {
   prev: HashMapLinkedNode<K, V>;
 };
 
-export type LinkedHashMapOptions<K> = {
+export type LinkedHashMapOptions<K, V, R> = {
   hashFn?: (key: K) => string;
   objHashFn?: (key: K) => object;
+  toEntryFn?: (rawElement: R) => [K, V];
 };
 
-export type HashMapOptions<K, V, T> = {
+export type HashMapOptions<K, V, R> = {
   hashFn?: (key: K) => string;
-  toEntryFn?: (rawElement: T) => [K, V];
+  toEntryFn?: (rawElement: R) => [K, V];
 };
 
 export type HashMapStoreItem<K, V> = { key: K; value: V };

package/src/types/utils/utils.ts

@@ -4,3 +4,5 @@ export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;
 
 export type SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+export type Any = string | number | boolean | object | null | undefined | symbol;