data-structure-typed 1.48.1 → 1.48.3

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

@@ -5,13 +5,13 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BSTNested, BSTNodeKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNKey, BTNodeExemplar, Comparator } from '../../types';
-import { CP, IterationType } from '../../types';
+import type { BSTNested, BSTNodeKeyOrNode, BSTNodeNested, BSTOptions, BTNCallback, BTNodeExemplar } from '../../types';
+import { BSTVariant, CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
-export declare class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extends BinaryTreeNode<V, N> {
+export declare class BSTNode<K = any, V = any, N extends BSTNode<K, V, N> = BSTNodeNested<K, V>> extends BinaryTreeNode<K, V, N> {
     parent?: N;
-    constructor(key: BTNKey, value?: V);
+    constructor(key: K, value?: V);
     protected _left?: N;
     /**
      * Get the left child node.
@@ -42,7 +42,7 @@ export declare class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>
  * 6. Balance Variability: Can become unbalanced; special types maintain balance.
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
  */
-export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>, TREE extends BST<V, N, TREE> = BST<V, N, BSTNested<V, N>>> extends BinaryTree<V, N, TREE> implements IBinaryTree<V, N, TREE> {
+export declare class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BSTNodeNested<K, V>>, TREE extends BST<K, V, N, TREE> = BST<K, V, N, BSTNested<K, V, N>>> extends BinaryTree<K, V, N, TREE> implements IBinaryTree<K, V, N, TREE> {
     /**
      * This is the constructor function for a binary search tree class in TypeScript, which initializes
      * the tree with optional elements and options.
@@ -51,19 +51,20 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @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(elements?: Iterable<BTNodeExemplar<V, N>>, options?: Partial<BSTOptions>);
+    constructor(elements?: Iterable<BTNodeExemplar<K, V, N>>, options?: Partial<BSTOptions<K>>);
     protected _root?: N;
     get root(): N | undefined;
-    comparator: Comparator<BTNKey>;
+    protected _variant: BSTVariant;
+    get variant(): BSTVariant;
     /**
      * 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.
      * @returns a new instance of the BSTNode class with the specified key and value.
      */
-    createNode(key: BTNKey, value?: V): N;
+    createNode(key: K, value?: V): N;
     /**
      * 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
@@ -71,20 +72,20 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * that defines various options for creating a binary search tree.
      * @returns a new instance of the BST class with the specified options.
      */
-    createTree(options?: Partial<BSTOptions>): TREE;
+    createTree(options?: Partial<BSTOptions<K>>): TREE;
     /**
      * 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: BTNodeExemplar<V, N>): exemplar is N;
+    isNode(exemplar: BTNodeExemplar<K, V, N>): exemplar is N;
     /**
      * 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: BTNodeExemplar<V, N>): N | undefined;
+    exemplarToNode(exemplar: BTNodeExemplar<K, V, N>): N | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
@@ -99,7 +100,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns The method returns either the newly added node (`newNode`) or `undefined` if the input
      * (`keyOrNodeOrEntry`) is null, undefined, or does not match any of the expected types.
      */
-    add(keyOrNodeOrEntry: BTNodeExemplar<V, N>): N | undefined;
+    add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>): N | undefined;
     /**
      * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
      * Space Complexity: O(k) - Additional space is required for the sorted array.
@@ -120,27 +121,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * tree instance.
      * @returns The `addMany` function returns an array of `N` or `undefined` values.
      */
-    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<V, N>>, isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
-    /**
-     * 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?: BSTNodeKeyOrNode<N>, iterationType?: IterationType): BTNKey;
+    addMany(keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>, isBalanceAdd?: boolean, iterationType?: IterationType): (N | undefined)[];
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(1) - Constant space is used.
@@ -151,7 +132,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      *
      * 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
@@ -159,7 +140,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns The function `getNodeByKey` returns a node (`N`) if a node with the specified key is
      * found in the binary tree. If no node is found, it returns `undefined`.
      */
-    getNodeByKey(key: BTNKey, iterationType?: IterationType): N | undefined;
+    getNodeByKey(key: K, iterationType?: IterationType): N | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -167,13 +148,13 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
     /**
      * 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: BSTNodeKeyOrNode<N>, iterationType?: IterationType): N | undefined;
+    ensureNode(key: BSTNodeKeyOrNode<K, N>, iterationType?: IterationType): N | undefined;
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -190,14 +171,14 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * 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
      * performed on the binary tree. It can have two possible values:
      * @returns The method returns an array of nodes (`N[]`).
      */
-    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BSTNodeKeyOrNode<N>, iterationType?: IterationType): N[];
+    getNodes<C extends BTNCallback<N>>(identifier: ReturnType<C> | undefined, callback?: C, onlyOne?: boolean, beginRoot?: BSTNodeKeyOrNode<K, N>, iterationType?: IterationType): N[];
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -215,7 +196,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * 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
@@ -223,7 +204,7 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BSTNodeKeyOrNode<N>, iterationType?: IterationType): ReturnType<C>[];
+    lesserOrGreaterTraverse<C extends BTNCallback<N>>(callback?: C, lesserOrGreater?: CP, targetNode?: BSTNodeKeyOrNode<K, N>, iterationType?: IterationType): ReturnType<C>[];
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. O(n) - Visiting each node once when identifier is not node's key.
      * Space Complexity: O(log n) - Space for the recursive call stack in the worst case.
@@ -267,10 +248,10 @@ export declare class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNe
     /**
      * 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).
      */
-    protected _compare(a: BTNKey, b: BTNKey): CP;
+    protected _compare(a: K, b: K): CP;
 }

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