min-heap-typed 1.50.2 → 1.50.4

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/dist/types/data-structures/binary-tree/avl-tree-multi-map.d.ts

@@ -0,0 +1,5 @@
+import { AVLTreeMultiMap, AVLTreeMultiMapNode } from '../../../data-structures';
+import type { AVLTreeOptions } from './avl-tree';
+export type AVLTreeMultiMapNodeNested<K, V> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AVLTreeMultiMapNested<K, V, N extends AVLTreeMultiMapNode<K, V, N>> = AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, AVLTreeMultiMap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type AVLTreeMultiMapOptions<K> = AVLTreeOptions<K> & {};

package/dist/types/data-structures/binary-tree/index.d.ts

@@ -2,5 +2,6 @@ export * from './binary-tree';
 export * from './bst';
 export * from './avl-tree';
 export * from './segment-tree';
-export * from './tree-multimap';
+export * from './avl-tree-multi-map';
 export * from './rb-tree';
+export * from './tree-multi-map';

package/dist/types/data-structures/binary-tree/index.js

@@ -18,5 +18,6 @@ __exportStar(require("./binary-tree"), exports);
 __exportStar(require("./bst"), exports);
 __exportStar(require("./avl-tree"), exports);
 __exportStar(require("./segment-tree"), exports);
-__exportStar(require("./tree-multimap"), exports);
+__exportStar(require("./avl-tree-multi-map"), exports);
 __exportStar(require("./rb-tree"), exports);
+__exportStar(require("./tree-multi-map"), exports);

package/dist/types/data-structures/binary-tree/tree-multi-map.d.ts

@@ -0,0 +1,5 @@
+import { TreeMultiMap, TreeMultiMapNode } from '../../../data-structures';
+import type { RBTreeOptions } from './rb-tree';
+export type TreeMultiMapNodeNested<K, V> = TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, TreeMultiMapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type TreeMultiMapNested<K, V, N extends TreeMultiMapNode<K, V, N>> = TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, TreeMultiMap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
+export type TreeMultiMapOptions<K> = RBTreeOptions<K> & {};

package/dist/types/data-structures/binary-tree/tree-multi-map.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "min-heap-typed",
-  "version": "1.50.2",
+  "version": "1.50.4",
   "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.4"
   }
 }

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/{tree-multimap.ts → avl-tree-multi-map.ts}

@@ -6,25 +6,23 @@
  * @license MIT License
  */
 import type {
+  AVLTreeMultiMapNested,
+  AVLTreeMultiMapNodeNested,
+  AVLTreeMultiMapOptions,
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNCallback,
-  KeyOrNodeOrEntry,
-  TreeMultimapNested,
-  TreeMultimapNodeNested,
-  TreeMultimapOptions
+  KeyOrNodeOrEntry
 } from '../../types';
 import { FamilyPosition, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 
-export class TreeMultimapNode<
+export class AVLTreeMultiMapNode<
   K = any,
   V = any,
-  NODE extends TreeMultimapNode<K, V, NODE> = TreeMultimapNodeNested<K, V>
+  NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNodeNested<K, V>
 > extends AVLTreeNode<K, V, NODE> {
-  count: number;
-
   /**
    * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
    * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
@@ -39,27 +37,51 @@ export class TreeMultimapNode<
     super(key, value);
     this.count = count;
   }
+
+  protected _count: number = 1;
+
+  /**
+   * The function returns the value of the protected variable _count.
+   * @returns The count property of the object, which is of type number.
+   */
+  get count(): number {
+    return this._count;
+  }
+
+  /**
+   * The above function sets the value of the count property.
+   * @param {number} value - The value parameter is of type number, which means it can accept any
+   * numeric value.
+   */
+  set count(value: number) {
+    this._count = value;
+  }
 }
 
 /**
- * The only distinction between a TreeMultimap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
+ * The only distinction between a AVLTreeMultiMap and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export class TreeMultimap<
+export class AVLTreeMultiMap<
   K = any,
   V = any,
-  NODE extends TreeMultimapNode<K, V, NODE> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>,
-  TREE extends TreeMultimap<K, V, NODE, TREE> = TreeMultimap<K, V, NODE, TreeMultimapNested<K, V, NODE>>
+  NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>,
+  TREE extends AVLTreeMultiMap<K, V, NODE, TREE> = AVLTreeMultiMap<K, V, NODE, AVLTreeMultiMapNested<K, V, NODE>>
 >
   extends AVLTree<K, V, NODE, TREE>
   implements IBinaryTree<K, V, NODE, TREE> {
-  constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>> = [], options?: TreeMultimapOptions<K>) {
+  constructor(keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>> = [], options?: AVLTreeMultiMapOptions<K>) {
     super([], options);
     if (keysOrNodesOrEntries) this.addMany(keysOrNodesOrEntries);
   }
 
-  private _count = 0;
+  protected _count = 0;
 
   // TODO the _count is not accurate after nodes count modified
+  /**
+   * The function calculates the sum of the count property of all nodes in a tree using depth-first
+   * search.
+   * @returns the sum of the count property of all nodes in the tree.
+   */
   get count(): number {
     let sum = 0;
     this.dfs(node => (sum += node.count));
@@ -76,11 +98,20 @@ export class TreeMultimap<
    * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
    */
   override createNode(key: K, value?: V, count?: number): NODE {
-    return new TreeMultimapNode(key, value, count) as NODE;
+    return new AVLTreeMultiMapNode(key, value, count) as NODE;
   }
 
-  override createTree(options?: TreeMultimapOptions<K>): TREE {
-    return new TreeMultimap<K, V, NODE, TREE>([], {
+  /**
+   * The function creates a new AVLTreeMultiMap object with the specified options and returns it.
+   * @param [options] - The `options` parameter is an optional object that contains additional
+   * configuration options for creating the `AVLTreeMultiMap` object. It can include properties such as
+   * `iterationType` and `variant`, which are used to specify the type of iteration and the variant of
+   * the tree, respectively. These properties can be
+   * @returns a new instance of the `AVLTreeMultiMap` class, with the provided options merged with the
+   * default options. The returned value is casted as `TREE`.
+   */
+  override createTree(options?: AVLTreeMultiMapOptions<K>): TREE {
+    return new AVLTreeMultiMap<K, V, NODE, TREE>([], {
       iterationType: this.iterationType,
       variant: this.variant,
       ...options
@@ -124,13 +155,13 @@ export class TreeMultimap<
   }
 
   /**
-   * The function checks if an keyOrNodeOrEntry is an instance of the TreeMultimapNode class.
+   * The function checks if an keyOrNodeOrEntry is an instance of the AVLTreeMultiMapNode class.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is of type `KeyOrNodeOrEntry<K, V, NODE>`.
-   * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the TreeMultimapNode
+   * @returns a boolean value indicating whether the keyOrNodeOrEntry is an instance of the AVLTreeMultiMapNode
    * class.
    */
   override isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE {
-    return keyOrNodeOrEntry instanceof TreeMultimapNode;
+    return keyOrNodeOrEntry instanceof AVLTreeMultiMapNode;
   }
 
   /**
@@ -375,6 +406,14 @@ export class TreeMultimap<
     return undefined;
   }
 
+  /**
+   * The function replaces an old node with a new node and updates the count property of the new node.
+   * @param {NODE} oldNode - The `oldNode` parameter is of type `NODE` and represents the node that
+   * needs to be replaced in a data structure.
+   * @param {NODE} newNode - The `newNode` parameter is an object of type `NODE`.
+   * @returns The method is returning the result of calling the `_replaceNode` method from the
+   * superclass, after updating the `count` property of the `newNode` object.
+   */
   protected _replaceNode(oldNode: NODE, newNode: NODE): NODE {
     newNode.count = oldNode.count + newNode.count;
     return super._replaceNode(oldNode, newNode);

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.
    */