min-heap-typed 1.50.2 → 1.50.3

package/dist/data-structures/trie/trie.js

@@ -8,9 +8,57 @@ const base_1 = require("../base");
  */
 class TrieNode {
     constructor(key) {
-        this.key = key;
-        this.isEnd = false;
-        this.children = new Map();
+        this._key = key;
+        this._isEnd = false;
+        this._children = new Map();
+    }
+    /**
+     * The function returns the value of the protected variable _key.
+     * @returns The value of the `_key` property, which is a string.
+     */
+    get key() {
+        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) {
+        this._key = value;
+    }
+    /**
+     * 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() {
+        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) {
+        this._children = value;
+    }
+    /**
+     * 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() {
+        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) {
+        this._isEnd = value;
     }
 }
 exports.TrieNode = TrieNode;
@@ -57,9 +105,8 @@ class Trie extends base_1.IterableElementBase {
         return this._size;
     }
     /**
-     * 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() {
         return this._caseSensitive;
@@ -72,12 +119,12 @@ class Trie extends base_1.IterableElementBase {
         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.
@@ -103,11 +150,11 @@ class Trie extends base_1.IterableElementBase {
         return isNewWord;
     }
     /**
-     * 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.
@@ -126,6 +173,13 @@ class Trie extends base_1.IterableElementBase {
         return cur.isEnd;
     }
     /**
+     * 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
      */
@@ -133,12 +187,26 @@ class Trie extends base_1.IterableElementBase {
         return this.size === 0;
     }
     /**
-     * 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 clear function resets the size of the Trie to 0 and creates a new root TrieNode.
+     */
+    clear() {
+        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(M), where M is the length of the word being deleted.
-     * Space Complexity: O(M) - 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.
@@ -180,11 +248,11 @@ class Trie extends base_1.IterableElementBase {
         return isDeleted;
     }
     /**
-     * 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.
      *
      */
@@ -208,11 +276,11 @@ class Trie extends base_1.IterableElementBase {
         return maxDepth;
     }
     /**
-     * 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.
@@ -231,11 +299,11 @@ class Trie extends base_1.IterableElementBase {
         return !cur.isEnd;
     }
     /**
-     * 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.
@@ -254,12 +322,12 @@ class Trie extends base_1.IterableElementBase {
         return true;
     }
     /**
-     * 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.
@@ -283,12 +351,12 @@ class Trie extends base_1.IterableElementBase {
         return commonPre === input;
     }
     /**
-     * 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.
@@ -308,12 +376,12 @@ class Trie extends base_1.IterableElementBase {
         return commonPre;
     }
     /**
-     * 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
@@ -422,6 +490,17 @@ class Trie extends base_1.IterableElementBase {
         }
         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.
+     */
     *_getIterator() {
         function* _dfs(node, path) {
             if (node.isEnd) {
@@ -434,11 +513,11 @@ class Trie extends base_1.IterableElementBase {
         yield* _dfs(this.root, '');
     }
     /**
-     * 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.50.2",
+  "version": "1.50.3",
   "description": "Min Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -132,6 +132,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.50.2"
+    "data-structure-typed": "^1.50.3"
   }
 }

package/src/data-structures/base/iterable-base.ts

@@ -289,8 +289,14 @@ export abstract class IterableEntryBase<K = any, V = any> {
 
   abstract isEmpty(): boolean;
 
+  abstract clear(): void;
+
   abstract clone(): any;
 
+  abstract map(...args: any[]): any;
+
+  abstract filter(...args: any[]): any;
+
   protected abstract _getIterator(...args: any[]): IterableIterator<[K, V]>;
 }
 
@@ -497,7 +503,13 @@ export abstract class IterableElementBase<E = any, C = any> {
 
   abstract isEmpty(): boolean;
 
+  abstract clear(): void;
+
   abstract clone(): C;
 
+  abstract map(...args: any[]): any;
+
+  abstract filter(...args: any[]): any;
+
   protected abstract _getIterator(...args: any[]): IterableIterator<E>;
 }

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

@@ -22,11 +22,36 @@ export class AVLTreeNode<
   V = any,
   NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNodeNested<K, V>
 > extends BSTNode<K, V, NODE> {
-  height: number;
-
+  /**
+   * The constructor function initializes a new instance of a class with a key and an optional value,
+   * and sets the height property to 0.
+   * @param {K} key - The "key" parameter is of type K, which represents the type of the key for the
+   * constructor. It is used to initialize the key property of the object being created.
+   * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
+   * value associated with the key in the constructor.
+   */
   constructor(key: K, value?: V) {
     super(key, value);
-    this.height = 0;
+    this._height = 0;
+  }
+
+  protected _height: number;
+
+  /**
+   * The function returns the value of the height property.
+   * @returns The height of the object.
+   */
+  get height(): number {
+    return this._height;
+  }
+
+  /**
+   * The above function sets the value of the height property.
+   * @param {number} value - The value parameter is a number that represents the new height value to be
+   * set.
+   */
+  set height(value: number) {
+    this._height = value;
   }
 }
 
@@ -488,6 +513,15 @@ export class AVLTree<
     }
   }
 
+  /**
+   * The function replaces an old node with a new node while preserving the height of the old node.
+   * @param {NODE} oldNode - The `oldNode` parameter is the node that you want to replace with the
+   * `newNode`.
+   * @param {NODE} newNode - The `newNode` parameter is the new node that will replace the `oldNode` in
+   * the data structure.
+   * @returns the result of calling the `_replaceNode` method on the superclass, passing in the
+   * `oldNode` and `newNode` as arguments.
+   */
   protected _replaceNode(oldNode: NODE, newNode: NODE): NODE {
     newNode.height = oldNode.height;
 

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

@@ -27,26 +27,48 @@ export class BinaryIndexedTree {
 
   protected _freqMap: Record<number, number>;
 
+  /**
+   * The function returns the frequency map of numbers.
+   * @returns The `_freqMap` property, which is a record with number keys and number values, is being
+   * returned.
+   */
   get freqMap(): Record<number, number> {
     return this._freqMap;
   }
 
   protected _msb: number;
 
+  /**
+   * The function returns the value of the _msb property.
+   * @returns The `_msb` property of the object.
+   */
   get msb(): number {
     return this._msb;
   }
 
   protected _negativeCount: number;
 
+  /**
+   * The function returns the value of the _negativeCount property.
+   * @returns The method is returning the value of the variable `_negativeCount`, which is of type
+   * `number`.
+   */
   get negativeCount(): number {
     return this._negativeCount;
   }
 
+  /**
+   * The above function returns the value of the protected variable `_freq`.
+   * @returns The frequency value stored in the protected variable `_freq`.
+   */
   get freq(): number {
     return this._freq;
   }
 
+  /**
+   * The above function returns the maximum value.
+   * @returns The maximum value stored in the variable `_max`.
+   */
   get max(): number {
     return this._max;
   }

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

@@ -44,7 +44,7 @@ export class BinaryTreeNode<
   /**
    * The constructor function initializes an object with a key and an optional value.
    * @param {K} key - The "key" parameter is of type K, which represents the type of the key for the
-   * constructor. It is used to set the value of the "key" property of the object being created.
+   * constructor. It is used to set the key property of the object being created.
    * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
    * value associated with the key in the constructor.
    */

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

@@ -34,10 +34,19 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
 
   protected override _left?: NODE;
 
+  /**
+   * The function returns the value of the `_left` property.
+   * @returns The `_left` property of the current object is being returned.
+   */
   override get left(): NODE | undefined {
     return this._left;
   }
 
+  /**
+   * The function sets the left child of a node and updates the parent reference of the child.
+   * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be an
+   * instance of the `NODE` class or `undefined`.
+   */
   override set left(v: NODE | undefined) {
     if (v) {
       v.parent = this as unknown as NODE;
@@ -47,10 +56,20 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
 
   protected override _right?: NODE;
 
+  /**
+   * The function returns the right node of a binary tree or undefined if there is no right node.
+   * @returns The method is returning the value of the `_right` property, which is of type `NODE` or
+   * `undefined`.
+   */
   override get right(): NODE | undefined {
     return this._right;
   }
 
+  /**
+   * The function sets the right child of a node and updates the parent reference of the child.
+   * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. It can either be a
+   * `NODE` object or `undefined`.
+   */
   override set right(v: NODE | undefined) {
     if (v) {
       v.parent = this as unknown as NODE;
@@ -77,10 +96,10 @@ export class BST<
   extends BinaryTree<K, V, NODE, TREE>
   implements IBinaryTree<K, V, NODE, TREE> {
   /**
-   * This is the constructor function for a binary search tree class in TypeScript, which initializes
-   * the tree with optional keysOrNodesOrEntries and options.
-   * @param [keysOrNodesOrEntries] - An optional iterable of KeyOrNodeOrEntry objects that will be added to the
-   * binary search tree.
+   * This is the constructor function for a TypeScript class that initializes a binary search tree with
+   * optional keys or nodes or entries and options.
+   * @param keysOrNodesOrEntries - An iterable object that contains keys, nodes, or entries. It is used
+   * to initialize the binary search tree with the provided keys, nodes, or entries.
    * @param [options] - The `options` parameter is an optional object that can contain additional
    * configuration options for the binary search tree. It can have the following properties:
    */
@@ -99,23 +118,31 @@ export class BST<
 
   protected override _root?: NODE;
 
+  /**
+   * The function returns the root node of a tree structure.
+   * @returns The `_root` property of the object, which is of type `NODE` or `undefined`.
+   */
   override get root(): NODE | undefined {
     return this._root;
   }
 
   protected _variant = BSTVariant.STANDARD;
 
+  /**
+   * The function returns the value of the _variant property.
+   * @returns The value of the `_variant` property.
+   */
   get variant() {
     return this._variant;
   }
 
   /**
-   * The function creates a new binary search tree node with the given key and value.
-   * @param {K} key - The key parameter is the key value that will be associated with
-   * the new node. It is used to determine the position of the node in the binary search tree.
-   * @param [value] - The parameter `value` is an optional value that can be assigned to the node. It
-   * represents the value associated with the node in a binary search tree.
-   * @returns a new instance of the BSTNode class with the specified key and value.
+   * The function creates a new BSTNode with the given key and value and returns it.
+   * @param {K} key - The key parameter is of type K, which represents the type of the key for the node
+   * being created.
+   * @param {V} [value] - The "value" parameter is an optional parameter of type V. It represents the
+   * value associated with the key in the node being created.
+   * @returns The method is returning a new instance of the BSTNode class, casted as the NODE type.
    */
   override createNode(key: K, value?: V): NODE {
     return new BSTNode<K, V, NODE>(key, value) as NODE;
@@ -124,9 +151,10 @@ export class BST<
   /**
    * The function creates a new binary search tree with the specified options.
    * @param [options] - The `options` parameter is an optional object that allows you to customize the
-   * behavior of the `createTree` method. It accepts a partial `BSTOptions` object, which is a type
-   * that defines various options for creating a binary search tree.
-   * @returns a new instance of the BST class with the specified options.
+   * behavior of the `createTree` method. It is of type `Partial<BSTOptions<K>>`, which means it is a
+   * partial object of type `BSTOptions<K>`.
+   * @returns a new instance of the BST class, with the provided options merged with the default
+   * options. The returned value is casted as TREE.
    */
   override createTree(options?: Partial<BSTOptions<K>>): TREE {
     return new BST<K, V, NODE, TREE>([], {
@@ -824,6 +852,11 @@ export class BST<
     return balanced;
   }
 
+  /**
+   * The function sets the root property of an object and updates the parent property of the new root.
+   * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. This means that it
+   * can either be an object of type `NODE` or it can be `undefined`.
+   */
   protected _setRoot(v: NODE | undefined) {
     if (v) {
       v.parent = undefined;