data-structure-typed 1.50.2 → 1.50.4

package/dist/mjs/data-structures/binary-tree/avl-tree.js

@@ -7,10 +7,33 @@
  */
 import { BST, BSTNode } from './bst';
 export class AVLTreeNode extends BSTNode {
-    height;
+    /**
+     * 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, value) {
         super(key, value);
-        this.height = 0;
+        this._height = 0;
+    }
+    _height;
+    /**
+     * The function returns the value of the height property.
+     * @returns The height of the object.
+     */
+    get height() {
+        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) {
+        this._height = value;
     }
 }
 /**
@@ -451,6 +474,15 @@ export class AVLTree extends BST {
             // TODO So far, no sure if this is necessary that Recursive Repair: Once rotation operations are executed, it may cause imbalance issues at higher levels of the tree. Therefore, you need to recursively check and repair imbalance problems upwards until you reach the root node.
         }
     }
+    /**
+     * 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.
+     */
     _replaceNode(oldNode, newNode) {
         newNode.height = oldNode.height;
         return super._replaceNode(oldNode, newNode);

package/dist/mjs/data-structures/binary-tree/binary-indexed-tree.d.ts

@@ -12,12 +12,34 @@ export declare class BinaryIndexedTree {
         max: number;
     });
     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>;
     protected _msb: number;
+    /**
+     * The function returns the value of the _msb property.
+     * @returns The `_msb` property of the object.
+     */
     get msb(): number;
     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;
+    /**
+     * The above function returns the value of the protected variable `_freq`.
+     * @returns The frequency value stored in the protected variable `_freq`.
+     */
     get freq(): number;
+    /**
+     * The above function returns the maximum value.
+     * @returns The maximum value stored in the variable `_max`.
+     */
     get max(): number;
     /**
      * The function "readSingle" reads a single number from a specified index.

package/dist/mjs/data-structures/binary-tree/binary-indexed-tree.js

@@ -23,20 +23,42 @@ export class BinaryIndexedTree {
         this._negativeCount = frequency < 0 ? max : 0;
     }
     _freqMap;
+    /**
+     * 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() {
         return this._freqMap;
     }
     _msb;
+    /**
+     * The function returns the value of the _msb property.
+     * @returns The `_msb` property of the object.
+     */
     get msb() {
         return this._msb;
     }
     _negativeCount;
+    /**
+     * 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() {
         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() {
         return this._freq;
     }
+    /**
+     * The above function returns the maximum value.
+     * @returns The maximum value stored in the variable `_max`.
+     */
     get max() {
         return this._max;
     }

package/dist/mjs/data-structures/binary-tree/binary-tree.d.ts

@@ -21,7 +21,7 @@ export declare class BinaryTreeNode<K = any, V = any, NODE extends BinaryTreeNod
     /**
      * 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/dist/mjs/data-structures/binary-tree/binary-tree.js

@@ -21,7 +21,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/dist/mjs/data-structures/binary-tree/bst.d.ts

@@ -13,10 +13,29 @@ export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE>
     parent?: NODE;
     constructor(key: K, value?: V);
     protected _left?: NODE;
+    /**
+     * The function returns the value of the `_left` property.
+     * @returns The `_left` property of the current object is being returned.
+     */
     get left(): NODE | undefined;
+    /**
+     * 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`.
+     */
     set left(v: NODE | undefined);
     protected _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`.
+     */
     get right(): NODE | undefined;
+    /**
+     * 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`.
+     */
     set right(v: NODE | undefined);
 }
 /**
@@ -30,33 +49,42 @@ export declare class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE>
  */
 export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, NODE, TREE> = BST<K, V, NODE, BSTNested<K, V, NODE>>> 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:
      */
     constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: BSTOptions<K>);
     protected _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`.
+     */
     get root(): NODE | undefined;
     protected _variant: BSTVariant;
+    /**
+     * The function returns the value of the _variant property.
+     * @returns The value of the `_variant` property.
+     */
     get variant(): BSTVariant;
     /**
-     * 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.
      */
     createNode(key: K, value?: V): NODE;
     /**
      * 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.
      */
     createTree(options?: Partial<BSTOptions<K>>): TREE;
     /**
@@ -333,6 +361,11 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * @returns a boolean value.
      */
     isAVLBalanced(iterationType?: IterationType): boolean;
+    /**
+     * 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): void;
     /**
      * The function compares two values using a comparator function and returns whether the first value

package/dist/mjs/data-structures/binary-tree/bst.js

@@ -10,9 +10,18 @@ export class BSTNode extends BinaryTreeNode {
         this._right = undefined;
     }
     _left;
+    /**
+     * The function returns the value of the `_left` property.
+     * @returns The `_left` property of the current object is being returned.
+     */
     get left() {
         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`.
+     */
     set left(v) {
         if (v) {
             v.parent = this;
@@ -20,9 +29,19 @@ export class BSTNode extends BinaryTreeNode {
         this._left = v;
     }
     _right;
+    /**
+     * 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`.
+     */
     get right() {
         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`.
+     */
     set right(v) {
         if (v) {
             v.parent = this;
@@ -41,10 +60,10 @@ export class BSTNode extends BinaryTreeNode {
  */
 export class BST extends BinaryTree {
     /**
-     * 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:
      */
@@ -60,20 +79,28 @@ export class BST extends BinaryTree {
             this.addMany(keysOrNodesOrEntries);
     }
     _root;
+    /**
+     * The function returns the root node of a tree structure.
+     * @returns The `_root` property of the object, which is of type `NODE` or `undefined`.
+     */
     get root() {
         return this._root;
     }
     _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.
      */
     createNode(key, value) {
         return new BSTNode(key, value);
@@ -81,9 +108,10 @@ export class BST extends BinaryTree {
     /**
      * 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.
      */
     createTree(options) {
         return new BST([], {
@@ -600,11 +628,9 @@ export class BST extends BinaryTree {
                 const compared = this._compare(cur.key, targetKey);
                 if (compared === lesserOrGreater)
                     ans.push(callback(cur));
-                if (!cur.left && !cur.right)
-                    return;
-                if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
+                if (this.isRealNode(cur.left))
                     _traverse(cur.left);
-                if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
+                if (this.isRealNode(cur.right))
                     _traverse(cur.right);
             };
             _traverse(this.root);
@@ -614,13 +640,13 @@ export class BST extends BinaryTree {
             const queue = new Queue([this.root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
-                if (cur) {
+                if (this.isRealNode(cur)) {
                     const compared = this._compare(cur.key, targetKey);
                     if (compared === lesserOrGreater)
                         ans.push(callback(cur));
-                    if (cur.left && this._compare(cur.left.key, targetKey) === lesserOrGreater)
+                    if (this.isRealNode(cur.left))
                         queue.push(cur.left);
-                    if (cur.right && this._compare(cur.right.key, targetKey) === lesserOrGreater)
+                    if (this.isRealNode(cur.right))
                         queue.push(cur.right);
                 }
             }
@@ -745,6 +771,11 @@ export class BST extends BinaryTree {
         }
         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`.
+     */
     _setRoot(v) {
         if (v) {
             v.parent = undefined;

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

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

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

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

package/dist/mjs/data-structures/binary-tree/rb-tree.d.ts

@@ -9,8 +9,29 @@ import { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry, R
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
-    color: RBTNColor;
+    /**
+     * The constructor function initializes a Red-Black Tree Node with a key, an optional value, and a
+     * color.
+     * @param {K} key - The key parameter is of type K and represents the key of the node in the
+     * Red-Black Tree.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the Red-Black Tree Node. It is not required and can be omitted when
+     * creating a new instance of the Red-Black Tree Node.
+     * @param {RBTNColor} color - The `color` parameter is used to specify the color of the Red-Black
+     * Tree Node. It is an optional parameter with a default value of `RBTNColor.BLACK`.
+     */
     constructor(key: K, value?: V, color?: RBTNColor);
+    protected _color: RBTNColor;
+    /**
+     * The function returns the color value of a variable.
+     * @returns The color value stored in the protected variable `_color`.
+     */
+    get color(): RBTNColor;
+    /**
+     * The function sets the color property to the specified value.
+     * @param {RBTNColor} value - The value parameter is of type RBTNColor.
+     */
+    set color(value: RBTNColor);
 }
 /**
  * 1. Each node is either red or black.
@@ -20,7 +41,6 @@ export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTre
  * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
  */
 export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, NODE, TREE> = RedBlackTree<K, V, NODE, RedBlackTreeNested<K, V, NODE>>> extends BST<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
-    Sentinel: NODE;
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional nodes and options.
@@ -33,9 +53,23 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
     constructor(keysOrNodesOrEntries?: Iterable<KeyOrNodeOrEntry<K, V, NODE>>, options?: RBTreeOptions<K>);
+    protected _Sentinel: NODE;
+    /**
+     * The function returns the value of the `_Sentinel` property.
+     * @returns The method is returning the value of the `_Sentinel` property.
+     */
+    get Sentinel(): NODE;
     protected _root: NODE;
+    /**
+     * The function returns the root node.
+     * @returns The root node of the data structure.
+     */
     get root(): NODE;
     protected _size: number;
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size(): number;
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
@@ -74,6 +108,12 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * class.
      */
     isNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>): keyOrNodeOrEntry is NODE;
+    /**
+     * The function checks if a given node is a real node in a Red-Black Tree.
+     * @param {NODE | undefined} node - The `node` parameter is of type `NODE | undefined`, which means
+     * it can either be of type `NODE` or `undefined`.
+     * @returns a boolean value.
+     */
     isRealNode(node: NODE | undefined): node is NODE;
     /**
      * Time Complexity: O(log n)
@@ -143,6 +183,12 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The "clear" function sets the root node to the sentinel node and resets the size to 0.
+     */
     clear(): void;
     /**
      * Time Complexity: O(log n)
@@ -158,6 +204,12 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * @returns the predecessor of the given RedBlackTreeNode 'x'.
      */
     getPredecessor(x: NODE): NODE;
+    /**
+     * The function sets the root node of a tree structure and updates the parent property of the new
+     * root node.
+     * @param {NODE} v - The parameter "v" is of type "NODE", which represents a node in a data
+     * structure.
+     */
     protected _setRoot(v: NODE): void;
     /**
      * Time Complexity: O(1)