min-heap-typed 1.50.2 → 1.50.3

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

@@ -1,25 +1,99 @@
 export class TreeNode<V = any> {
-  key: string;
-  value?: V | undefined;
-  children?: TreeNode<V>[] | undefined;
-
+  /**
+   * The constructor function initializes a TreeNode object with a key, optional value, and optional
+   * children.
+   * @param {string} key - A string representing the key of the tree node.
+   * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
+   * value associated with the node. If no value is provided, it defaults to `undefined`.
+   * @param {TreeNode<V>[]} [children] - The `children` parameter is an optional array of `TreeNode<V>`
+   * objects. It represents the child nodes of the current node. If no children are provided, the
+   * default value is an empty array.
+   */
   constructor(key: string, value?: V, children?: TreeNode<V>[]) {
-    this.key = key;
-    this.value = value || undefined;
-    this.children = children || [];
+    this._key = key;
+    this._value = value || undefined;
+    this._children = children || [];
+  }
+
+  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 _value?: V | undefined;
+
+  /**
+   * The function returns the value stored in a variable, or undefined if the variable is empty.
+   * @returns The value of the variable `_value` is being returned.
+   */
+  get value(): V | undefined {
+    return this._value;
+  }
+
+  /**
+   * The function sets the value of a variable.
+   * @param {V | undefined} value - The parameter "value" is of type "V | undefined", which means it
+   * can accept a value of type "V" or it can be undefined.
+   */
+  set value(value: V | undefined) {
+    this._value = value;
+  }
+
+  protected _children?: TreeNode<V>[] | undefined;
+
+  /**
+   * The function returns an array of TreeNode objects or undefined.
+   * @returns The `children` property is being returned. It is of type `TreeNode<V>[] | undefined`,
+   * which means it can either be an array of `TreeNode<V>` objects or `undefined`.
+   */
+  get children(): TreeNode<V>[] | undefined {
+    return this._children;
+  }
+
+  /**
+   * The function sets the value of the children property of a TreeNode object.
+   * @param {TreeNode<V>[] | undefined} value - The value parameter is of type TreeNode<V>[] |
+   * undefined. This means that it can accept an array of TreeNode objects or undefined.
+   */
+  set children(value: TreeNode<V>[] | undefined) {
+    this._children = value;
   }
 
+  /**
+   * The function `addChildren` adds one or more child nodes to the current node.
+   * @param {TreeNode<V> | TreeNode<V>[]} children - The `children` parameter can be either a single
+   * `TreeNode<V>` object or an array of `TreeNode<V>` objects.
+   */
   addChildren(children: TreeNode<V> | TreeNode<V>[]) {
-    if (!this.children) {
-      this.children = [];
+    if (!this._children) {
+      this._children = [];
     }
     if (children instanceof TreeNode) {
-      this.children.push(children);
+      this._children.push(children);
     } else {
-      this.children = this.children.concat(children);
+      this._children = this._children.concat(children);
     }
   }
 
+  /**
+   * The function `getHeight()` calculates the maximum depth of a tree structure by performing a
+   * breadth-first search.
+   * @returns the maximum depth or height of the tree.
+   */
   getHeight() {
     let maxDepth = 0;
     if (this) {
@@ -27,10 +101,10 @@ export class TreeNode<V = any> {
         if (level > maxDepth) {
           maxDepth = level;
         }
-        const { children } = node;
-        if (children) {
-          for (let i = 0, len = children.length; i < len; i++) {
-            bfs(children[i], level + 1);
+        const { _children } = node;
+        if (_children) {
+          for (let i = 0, len = _children.length; i < len; i++) {
+            bfs(_children[i], level + 1);
           }
         }
       };

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;
   }
 }
 
@@ -68,9 +124,8 @@ export class Trie extends IterableElementBase<string, Trie> {
   protected _caseSensitive: boolean = true;
 
   /**
-   * The caseSensitive function is a getter that returns the value of the private _caseSensitive property.
-   *
-   * @return The value of the _casesensitive private variable
+   * 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;
@@ -87,13 +142,13 @@ export class Trie extends IterableElementBase<string, Trie> {
   }
 
   /**
-   * 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.
@@ -120,12 +175,12 @@ export class Trie extends IterableElementBase<string, Trie> {
   }
 
   /**
-   * 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.
@@ -144,6 +199,14 @@ export class Trie extends IterableElementBase<string, Trie> {
   }
 
   /**
+   * 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
    */
@@ -152,13 +215,29 @@ export class Trie extends IterableElementBase<string, Trie> {
   }
 
   /**
-   * 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(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.
@@ -201,12 +280,12 @@ export class Trie extends IterableElementBase<string, Trie> {
   }
 
   /**
-   * 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.
    *
    */
@@ -231,12 +310,12 @@ export class Trie extends IterableElementBase<string, Trie> {
   }
 
   /**
-   * 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.
@@ -255,12 +334,12 @@ export class Trie extends IterableElementBase<string, Trie> {
   }
 
   /**
-   * 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.
@@ -279,13 +358,13 @@ export class Trie extends IterableElementBase<string, Trie> {
   }
 
   /**
-   * 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.
@@ -306,13 +385,13 @@ export class Trie extends IterableElementBase<string, Trie> {
   }
 
   /**
-   * 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.
@@ -330,13 +409,13 @@ export class Trie extends IterableElementBase<string, Trie> {
   }
 
   /**
-   * 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
@@ -454,6 +533,18 @@ export class Trie extends IterableElementBase<string, Trie> {
     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) {
@@ -468,12 +559,12 @@ export class Trie extends IterableElementBase<string, Trie> {
   }
 
   /**
-   * 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