data-structure-typed 1.48.2 → 1.48.3

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

@@ -1,4 +1,4 @@
-import { CP, IterationType } from '../../types';
+import { BSTVariant, CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { Queue } from '../queue';
 export class BSTNode extends BinaryTreeNode {
@@ -65,9 +65,9 @@ export class BST extends BinaryTree {
     constructor(elements, options) {
         super([], options);
         if (options) {
-            const { comparator } = options;
-            if (comparator) {
-                this.comparator = comparator;
+            const { variant } = options;
+            if (variant) {
+                this._variant = variant;
             }
         }
         this._root = undefined;
@@ -78,10 +78,13 @@ export class BST extends BinaryTree {
     get root() {
         return this._root;
     }
-    comparator = (a, b) => a - b;
+    _variant = BSTVariant.MIN;
+    get variant() {
+        return this._variant;
+    }
     /**
      * The function creates a new binary search tree node with the given key and value.
-     * @param {BTNKey} key - The key parameter is the key value that will be associated with
+     * @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.
@@ -100,12 +103,12 @@ export class BST extends BinaryTree {
     createTree(options) {
         return new BST([], {
             iterationType: this.iterationType,
-            comparator: this.comparator, ...options
+            variant: this.variant, ...options
         });
     }
     /**
      * The function checks if an exemplar is an instance of BSTNode.
-     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
      */
     isNode(exemplar) {
@@ -114,7 +117,7 @@ export class BST extends BinaryTree {
     /**
      * The function `exemplarToNode` takes an exemplar and returns a corresponding node if the exemplar
      * is valid, otherwise it returns undefined.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a variable `node` which is of type `N` or `undefined`.
      */
     exemplarToNode(exemplar) {
@@ -134,7 +137,7 @@ export class BST extends BinaryTree {
                 node = this.createNode(key, value);
             }
         }
-        else if (this.isNodeKey(exemplar)) {
+        else if (this.isNotNodeInstance(exemplar)) {
             node = this.createNode(exemplar);
         }
         else {
@@ -242,17 +245,17 @@ export class BST extends BinaryTree {
         sorted = realBTNExemplars.sort((a, b) => {
             let aR, bR;
             if (this.isEntry(a))
-                aR = a[0];
+                aR = this.extractor(a[0]);
             else if (this.isRealNode(a))
-                aR = a.key;
+                aR = this.extractor(a.key);
             else
-                aR = a;
+                aR = this.extractor(a);
             if (this.isEntry(b))
-                bR = b[0];
+                bR = this.extractor(b[0]);
             else if (this.isRealNode(b))
-                bR = b.key;
+                bR = this.extractor(b.key);
             else
-                bR = b;
+                bR = this.extractor(b);
             return aR - bR;
         });
         const _dfs = (arr) => {
@@ -289,33 +292,31 @@ export class BST extends BinaryTree {
         }
         return inserted;
     }
-    /**
-     * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
-     * Space Complexity: O(n) - Additional space is required for the sorted array.
-     */
-    /**
-     * Time Complexity: O(log n) - Average case for a balanced tree.
-     * Space Complexity: O(1) - Constant space is used.
-     *
-     * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
-     * leftmost node if the comparison result is greater than.
-     * @param {BTNKey | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-     * type `BTNKey`, `N`, or `undefined`. It represents the starting point for finding the last key in
-     * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
-     * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
-     * be performed. It can have one of the following values:
-     * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
-     * the key of the leftmost node if the comparison result is greater than, and the key of the
-     * rightmost node otherwise. If no node is found, it returns 0.
-     */
-    lastKey(beginRoot = this.root, iterationType = this.iterationType) {
-        if (this._compare(0, 1) === CP.lt)
-            return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
-        else if (this._compare(0, 1) === CP.gt)
-            return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
-        else
-            return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
-    }
+    // /**
+    //  * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
+    //  * Space Complexity: O(n) - Additional space is required for the sorted array.
+    //  */
+    //
+    // /**
+    //  * Time Complexity: O(log n) - Average case for a balanced tree.
+    //  * Space Complexity: O(1) - Constant space is used.
+    //  *
+    //  * The `lastKey` function returns the key of the rightmost node in a binary tree, or the key of the
+    //  * leftmost node if the comparison result is greater than.
+    //  * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
+    //  * type `K`, `N`, or `undefined`. It represents the starting point for finding the last key in
+    //  * the binary tree. If not provided, it defaults to the root of the binary tree (`this.root`).
+    //  * @param iterationType - The `iterationType` parameter is used to specify the type of iteration to
+    //  * be performed. It can have one of the following values:
+    //  * @returns the key of the rightmost node in the binary tree if the comparison result is less than,
+    //  * the key of the leftmost node if the comparison result is greater than, and the key of the
+    //  * rightmost node otherwise. If no node is found, it returns 0.
+    //  */
+    // lastKey(beginRoot: BSTNodeKeyOrNode<K,N> = this.root, iterationType = this.iterationType): K {
+    //   if (this._compare(0, 1) === CP.lt) return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
+    //   else if (this._compare(0, 1) === CP.gt) return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
+    //   else return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
+    // }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(1) - Constant space is used.
@@ -326,7 +327,7 @@ export class BST extends BinaryTree {
      *
      * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
      * either recursive or iterative methods.
-     * @param {BTNKey} key - The `key` parameter is the key value that we are searching for in the tree.
+     * @param {K} key - The `key` parameter is the key value that we are searching for in the tree.
      * It is used to identify the node that we want to retrieve.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to use when searching for a node in the binary tree. It can have two possible
@@ -372,14 +373,14 @@ export class BST extends BinaryTree {
     /**
      * The function `ensureNode` returns the node corresponding to the given key if it is a node key,
      * otherwise it returns the key itself.
-     * @param {BTNKey | N | undefined} key - The `key` parameter can be of type `BTNKey`, `N`, or
+     * @param {K | N | undefined} key - The `key` parameter can be of type `K`, `N`, or
      * `undefined`.
      * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
      * @returns either a node object (N) or undefined.
      */
     ensureNode(key, iterationType = IterationType.ITERATIVE) {
-        return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
+        return this.isNotNodeInstance(key) ? this.getNodeByKey(key, iterationType) : key;
     }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
@@ -397,7 +398,7 @@ export class BST extends BinaryTree {
      * first node that matches the identifier. If set to true, the function will return an array
      * containing only the first matching node. If set to false (default), the function will continue
      * searching for all nodes that match the identifier and return an array containing
-     * @param {BTNKey | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
+     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter represents the starting node
      * for the traversal. It can be either a key value or a node object. If it is undefined, the
      * traversal will start from the root of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of iteration to be
@@ -477,7 +478,7 @@ export class BST extends BinaryTree {
      * traverse nodes that are lesser than, greater than, or equal to the `targetNode`. It is of type
      * `CP`, which is a custom type representing the comparison operator. The possible values for
      * `lesserOrGreater` are
-     * @param {BTNKey | N | undefined} targetNode - The `targetNode` parameter represents the node in the
+     * @param {K | N | undefined} targetNode - The `targetNode` parameter represents the node in the
      * binary tree that you want to traverse from. It can be specified either by its key, by the node
      * object itself, or it can be left undefined to start the traversal from the root of the tree.
      * @param iterationType - The `iterationType` parameter determines the type of traversal to be
@@ -653,18 +654,15 @@ export class BST extends BinaryTree {
     /**
      * The function compares two values using a comparator function and returns whether the first value
      * is greater than, less than, or equal to the second value.
-     * @param {BTNKey} a - The parameter "a" is of type BTNKey.
-     * @param {BTNKey} b - The parameter "b" in the above code represents a BTNKey.
+     * @param {K} a - The parameter "a" is of type K.
+     * @param {K} b - The parameter "b" in the above code represents a K.
      * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater
      * than), CP.lt (less than), or CP.eq (equal).
      */
     _compare(a, b) {
-        const compared = this.comparator(a, b);
-        if (compared > 0)
-            return CP.gt;
-        else if (compared < 0)
-            return CP.lt;
-        else
-            return CP.eq;
+        const extractedA = this.extractor(a);
+        const extractedB = this.extractor(b);
+        const compared = this.variant === BSTVariant.MIN ? extractedA - extractedB : extractedB - extractedA;
+        return compared > 0 ? CP.gt : compared < 0 ? CP.lt : CP.eq;
     }
 }

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

@@ -5,12 +5,12 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BiTreeDeleteResult, BTNCallback, BTNKey, BTNodeExemplar, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import { BiTreeDeleteResult, BTNCallback, BTNodeExemplar, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
-export declare class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNodeNested<V>> extends BSTNode<V, N> {
+export declare class RedBlackTreeNode<K = any, V = any, N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, N> {
     color: RBTNColor;
-    constructor(key: BTNKey, value?: V, color?: RBTNColor);
+    constructor(key: K, value?: V, color?: RBTNColor);
 }
 /**
  * 1. Each node is either red or black.
@@ -19,12 +19,12 @@ export declare class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N>
  * 4. Red nodes must have black children.
  * 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<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNode<V, RedBlackTreeNodeNested<V>>, TREE extends RedBlackTree<V, N, TREE> = RedBlackTree<V, N, RedBlackTreeNested<V, N>>> extends BST<V, N, TREE> implements IBinaryTree<V, N, TREE> {
+export declare class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N> = RedBlackTreeNode<K, V, RedBlackTreeNodeNested<K, V>>, TREE extends RedBlackTree<K, V, N, TREE> = RedBlackTree<K, V, N, RedBlackTreeNested<K, V, N>>> extends BST<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
     Sentinel: N;
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
      * objects. It represents the initial elements that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * elements to the
@@ -32,14 +32,14 @@ export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = Re
      * behavior of the RBTree. It is of type `Partial<RBTreeOptions>`, which means that you can provide
      * only a subset of the properties defined in the `RBTreeOptions` interface.
      */
-    constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<RBTreeOptions>);
+    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<RBTreeOptions<K>>);
     protected _root: N;
     get root(): N;
     protected _size: number;
     get size(): number;
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
-     * @param {BTNKey} key - The key parameter is the key value associated with the node. It is used to
+     * @param {K} key - The key parameter is the key value associated with the node. It is used to
      * identify and compare nodes in the Red-Black Tree.
      * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
      * associated with the node. It is of type `V`, which is a generic type that can be replaced with any
@@ -49,7 +49,7 @@ export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = Re
      * @returns The method is returning a new instance of a RedBlackTreeNode with the specified key,
      * value, and color.
      */
-    createNode(key: BTNKey, value?: V, color?: RBTNColor): N;
+    createNode(key: K, value?: V, color?: RBTNColor): N;
     /**
      * The function creates a Red-Black Tree with the specified options and returns it.
      * @param {RBTreeOptions} [options] - The `options` parameter is an optional object that can be
@@ -57,23 +57,23 @@ export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = Re
      * class.
      * @returns a new instance of a RedBlackTree object.
      */
-    createTree(options?: RBTreeOptions): TREE;
+    createTree(options?: RBTreeOptions<K>): TREE;
     /**
      * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
      * class.
      */
-    isNode(exemplar: BTNodeExemplar<V, N>): exemplar is N;
+    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
     /**
      * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
      * otherwise it returns undefined.
-     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing an exemplar of a binary tree
+     * @param exemplar - BTNodeExemplar<K, V, N> - A generic type representing an exemplar of a binary tree
      * node. It can be either a node itself, an entry (key-value pair), a node key, or any other value
      * that is not a valid exemplar.
      * @returns a variable `node` which is of type `N | undefined`.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<V, N>): N | undefined;
+    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>): N | undefined;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -84,7 +84,7 @@ export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = Re
      * @returns The method `add` returns either an instance of `N` (the node that was added) or
      * `undefined`.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>): N | undefined;
+    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>): N | undefined;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)
@@ -110,7 +110,7 @@ export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = Re
      * Space Complexity: O(1)
      */
     isRealNode(node: N | undefined): node is N;
-    getNode<C extends BTNCallback<N, BTNKey>>(identifier: BTNKey, callback?: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
+    getNode<C extends BTNCallback<N, K>>(identifier: K, callback?: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
     getNode<C extends BTNCallback<N, N>>(identifier: N | undefined, callback?: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
     getNode<C extends BTNCallback<N>>(identifier: ReturnType<C>, callback: C, beginRoot?: N | undefined, iterationType?: IterationType): N | undefined;
     /**

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

@@ -27,7 +27,7 @@ export class RedBlackTree extends BST {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript, which
      * initializes the tree with optional elements and options.
-     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<V, N>`
+     * @param [elements] - The `elements` parameter is an optional iterable of `BTNodeExemplar<K, V, N>`
      * objects. It represents the initial elements that will be added to the RBTree during its
      * construction. If this parameter is provided, the `addMany` method is called to add all the
      * elements to the
@@ -51,7 +51,7 @@ export class RedBlackTree extends BST {
     }
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
-     * @param {BTNKey} key - The key parameter is the key value associated with the node. It is used to
+     * @param {K} key - The key parameter is the key value associated with the node. It is used to
      * identify and compare nodes in the Red-Black Tree.
      * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
      * associated with the node. It is of type `V`, which is a generic type that can be replaced with any
@@ -74,12 +74,12 @@ export class RedBlackTree extends BST {
     createTree(options) {
         return new RedBlackTree([], {
             iterationType: this.iterationType,
-            comparator: this.comparator, ...options
+            variant: this.variant, ...options
         });
     }
     /**
      * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
      * class.
      */
@@ -89,7 +89,7 @@ export class RedBlackTree extends BST {
     /**
      * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
      * otherwise it returns undefined.
-     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing an exemplar of a binary tree
+     * @param exemplar - BTNodeExemplar<K, V, N> - A generic type representing an exemplar of a binary tree
      * node. It can be either a node itself, an entry (key-value pair), a node key, or any other value
      * that is not a valid exemplar.
      * @returns a variable `node` which is of type `N | undefined`.
@@ -111,7 +111,7 @@ export class RedBlackTree extends BST {
                 node = this.createNode(key, value, RBTNColor.RED);
             }
         }
-        else if (this.isNodeKey(exemplar)) {
+        else if (this.isNotNodeInstance(exemplar)) {
             node = this.createNode(exemplar, undefined, RBTNColor.RED);
         }
         else {
@@ -277,7 +277,7 @@ export class RedBlackTree extends BST {
      * @param {C} callback - The `callback` parameter is a function that will be called for each node in
      * the binary tree. It is used to determine if a node matches the given identifier. The `callback`
      * function should take a single parameter of type `N` (the type of the nodes in the binary tree) and
-     * @param {BTNKey | N | undefined} beginRoot - The `beginRoot` parameter is the starting point for
+     * @param {K | N | undefined} beginRoot - The `beginRoot` parameter is the starting point for
      * searching for a node in a binary tree. It can be either a key value or a node object. If it is not
      * provided, the search will start from the root of the binary tree.
      * @param iterationType - The `iterationType` parameter is a variable that determines the type of

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

@@ -5,15 +5,15 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNodeKeyOrNode, BTNKey, BTNodeExemplar, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
+import type { BSTNodeKeyOrNode, BTNodeExemplar, TreeMultimapNodeNested, TreeMultimapOptions } from '../../types';
 import { BiTreeDeleteResult, BTNCallback, IterationType, TreeMultimapNested } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
-export declare class TreeMultimapNode<V = any, N extends TreeMultimapNode<V, N> = TreeMultimapNodeNested<V>> extends AVLTreeNode<V, N> {
+export declare class TreeMultimapNode<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNodeNested<K, V>> extends AVLTreeNode<K, V, N> {
     count: number;
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
-     * @param {BTNKey} key - The `key` parameter is of type `BTNKey` and represents the unique identifier
+     * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
      * of the binary tree node.
      * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the value of the binary
      * tree node. If no value is provided, it will be `undefined`.
@@ -21,42 +21,42 @@ export declare class TreeMultimapNode<V = any, N extends TreeMultimapNode<V, N>
      * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
      * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
-    constructor(key: BTNKey, value?: V, count?: number);
+    constructor(key: K, value?: V, count?: number);
 }
 /**
  * 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.
  */
-export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = TreeMultimapNode<V, TreeMultimapNodeNested<V>>, TREE extends TreeMultimap<V, N, TREE> = TreeMultimap<V, N, TreeMultimapNested<V, N>>> extends AVLTree<V, N, TREE> implements IBinaryTree<V, N, TREE> {
-    constructor(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<TreeMultimapOptions>);
+export declare class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N> = TreeMultimapNode<K, V, TreeMultimapNodeNested<K, V>>, TREE extends TreeMultimap<K, V, N, TREE> = TreeMultimap<K, V, N, TreeMultimapNested<K, V, N>>> extends AVLTree<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
+    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<TreeMultimapOptions<K>>);
     private _count;
     get count(): number;
     /**
      * The function creates a new BSTNode with the given key, value, and count.
-     * @param {BTNKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
+     * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
      * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
      * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
      * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
-    createNode(key: BTNKey, value?: V, count?: number): N;
-    createTree(options?: TreeMultimapOptions): TREE;
+    createNode(key: K, value?: V, count?: number): N;
+    createTree(options?: TreeMultimapOptions<K>): TREE;
     /**
      * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
      * class.
      */
-    isNode(exemplar: BTNodeExemplar<V, N>): exemplar is N;
+    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`, where `V` represents
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where `V` represents
      * the value type and `N` represents the node type.
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
      * times the node should be created. If not provided, it defaults to 1.
      * @returns a value of type `N` (the generic type parameter) or `undefined`.
      */
-    exemplarToNode(exemplar: BTNodeExemplar<V, N>, count?: number): N | undefined;
+    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>, count?: number): N | undefined;
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -73,7 +73,7 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * is 1.
      * @returns either a node (`N`) or `undefined`.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>, count?: number): N | undefined;
+    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, count?: number): N | undefined;
     /**
      * Time Complexity: O(k log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -88,7 +88,7 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * either keys, nodes, or entries.
      * @returns The method is returning an array of type `N | undefined`.
      */
-    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<V, N>>): (N | undefined)[];
+    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>): (N | undefined)[];
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.
@@ -158,22 +158,22 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * @param {N | undefined} newNode - The `newNode` parameter represents the node that needs to be
      * added to the binary tree. It can be of type `N` (which represents a node in the binary tree) or
      * `undefined` if there is no node to add.
-     * @param {BTNKey | N | undefined} parent - The `parent` parameter represents the parent node to
+     * @param {K | N | undefined} parent - The `parent` parameter represents the parent node to
      * which the new node will be added as a child. It can be either a node object (`N`) or a key value
-     * (`BTNKey`).
+     * (`K`).
      * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
      * added, or `undefined` if no node was added.
      */
-    protected _addTo(newNode: N | undefined, parent: BSTNodeKeyOrNode<N>): N | undefined;
+    protected _addTo(newNode: N | undefined, parent: BSTNodeKeyOrNode<K, N>): N | undefined;
     /**
      * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
-     * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node from
-     * which the values will be swapped. It can be of type `BTNKey`, `N`, or `undefined`.
-     * @param {BTNKey | N | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from
+     * which the values will be swapped. It can be of type `K`, `N`, or `undefined`.
+     * @param {K | N | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.
      */
-    protected _swapProperties(srcNode: BSTNodeKeyOrNode<N>, destNode: BSTNodeKeyOrNode<N>): N | undefined;
+    protected _swapProperties(srcNode: BSTNodeKeyOrNode<K, N>, destNode: BSTNodeKeyOrNode<K, N>): N | undefined;
     protected _replaceNode(oldNode: N, newNode: N): N;
 }

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

@@ -4,7 +4,7 @@ export class TreeMultimapNode extends AVLTreeNode {
     count;
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
-     * @param {BTNKey} key - The `key` parameter is of type `BTNKey` and represents the unique identifier
+     * @param {K} key - The `key` parameter is of type `K` and represents the unique identifier
      * of the binary tree node.
      * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the value of the binary
      * tree node. If no value is provided, it will be `undefined`.
@@ -35,7 +35,7 @@ export class TreeMultimap extends AVLTree {
     }
     /**
      * The function creates a new BSTNode with the given key, value, and count.
-     * @param {BTNKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
+     * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
      * @param {N} value - The `value` parameter represents the value that will be stored in the binary search tree node.
      * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
@@ -48,12 +48,12 @@ export class TreeMultimap extends AVLTree {
     createTree(options) {
         return new TreeMultimap([], {
             iterationType: this.iterationType,
-            comparator: this.comparator, ...options
+            variant: this.variant, ...options
         });
     }
     /**
      * The function checks if an exemplar is an instance of the TreeMultimapNode class.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`.
      * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
      * class.
      */
@@ -62,7 +62,7 @@ export class TreeMultimap extends AVLTree {
     }
     /**
      * The function `exemplarToNode` converts an exemplar object into a node object.
-     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`, where `V` represents
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<K, V, N>`, where `V` represents
      * the value type and `N` represents the node type.
      * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
      * times the node should be created. If not provided, it defaults to 1.
@@ -85,7 +85,7 @@ export class TreeMultimap extends AVLTree {
                 node = this.createNode(key, value, count);
             }
         }
-        else if (this.isNodeKey(exemplar)) {
+        else if (this.isNotNodeInstance(exemplar)) {
             node = this.createNode(exemplar, undefined, count);
         }
         else {
@@ -304,9 +304,9 @@ export class TreeMultimap extends AVLTree {
      * @param {N | undefined} newNode - The `newNode` parameter represents the node that needs to be
      * added to the binary tree. It can be of type `N` (which represents a node in the binary tree) or
      * `undefined` if there is no node to add.
-     * @param {BTNKey | N | undefined} parent - The `parent` parameter represents the parent node to
+     * @param {K | N | undefined} parent - The `parent` parameter represents the parent node to
      * which the new node will be added as a child. It can be either a node object (`N`) or a key value
-     * (`BTNKey`).
+     * (`K`).
      * @returns The method `_addTo` returns either the `parent.left` or `parent.right` node that was
      * added, or `undefined` if no node was added.
      */
@@ -339,9 +339,9 @@ export class TreeMultimap extends AVLTree {
     }
     /**
      * The `_swapProperties` function swaps the key, value, count, and height properties between two nodes.
-     * @param {BTNKey | N | undefined} srcNode - The `srcNode` parameter represents the source node from
-     * which the values will be swapped. It can be of type `BTNKey`, `N`, or `undefined`.
-     * @param {BTNKey | N | undefined} destNode - The `destNode` parameter represents the destination
+     * @param {K | N | undefined} srcNode - The `srcNode` parameter represents the source node from
+     * which the values will be swapped. It can be of type `K`, `N`, or `undefined`.
+     * @param {K | N | undefined} destNode - The `destNode` parameter represents the destination
      * node where the values from the source node will be swapped to.
      * @returns either the `destNode` object if both `srcNode` and `destNode` are defined, or `undefined`
      * if either `srcNode` or `destNode` is undefined.

package/dist/mjs/interfaces/binary-tree.d.ts

@@ -1,9 +1,9 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import { BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BiTreeDeleteResult, BTNCallback, BTNKey, BTNodeExemplar } from '../types';
-export interface IBinaryTree<V = any, N extends BinaryTreeNode<V, N> = BinaryTreeNodeNested<V>, TREE extends BinaryTree<V, N, TREE> = BinaryTreeNested<V, N>> {
-    createNode(key: BTNKey, value?: N['value']): N;
-    createTree(options?: Partial<BinaryTreeOptions>): TREE;
-    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>, count?: number): N | null | undefined;
-    addMany(nodes: Iterable<BTNodeExemplar<V, N>>): (N | null | undefined)[];
+import { BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BiTreeDeleteResult, BTNCallback, BTNodeExemplar } from '../types';
+export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTreeNested<K, V, N>> {
+    createNode(key: K, value?: N['value']): N;
+    createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
+    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, count?: number): N | null | undefined;
+    addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>): (N | null | undefined)[];
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BiTreeDeleteResult<N>[];
 }

package/dist/mjs/types/common.d.ts

@@ -1,5 +1,8 @@
-import { BTNKey } from "./data-structures";
-export type Comparator<T> = (a: T, b: T) => number;
+export type Comparator<K> = (a: K, b: K) => number;
+export declare enum BSTVariant {
+    MIN = "MIN",
+    MAX = "MAX"
+}
 export type DFSOrderPattern = 'pre' | 'in' | 'post';
 export type BTNCallback<N, D = any> = (node: N) => D;
 export declare enum CP {
@@ -19,9 +22,9 @@ export type BinaryTreePrintOptions = {
     isShowNull?: boolean;
     isShowRedBlackNIL?: boolean;
 };
-export type BTNodeEntry<T> = [BTNKey | null | undefined, T | undefined];
-export type BTNodeKeyOrNode<N> = BTNKey | null | undefined | N;
-export type BTNodeExemplar<T, N> = BTNodeEntry<T> | BTNodeKeyOrNode<N>;
-export type BTNodePureExemplar<T, N> = [BTNKey, T | undefined] | BTNodePureKeyOrNode<N>;
-export type BTNodePureKeyOrNode<N> = BTNKey | N;
-export type BSTNodeKeyOrNode<N> = BTNKey | undefined | N;
+export type BTNodeEntry<K, V> = [K | null | undefined, V | undefined];
+export type BTNodeKeyOrNode<K, N> = K | null | undefined | N;
+export type BTNodeExemplar<K, V, N> = BTNodeEntry<K, V> | BTNodeKeyOrNode<K, N>;
+export type BTNodePureExemplar<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>;
+export type BTNodePureKeyOrNode<K, N> = K | N;
+export type BSTNodeKeyOrNode<K, N> = K | undefined | N;