undirected-graph-typed 1.51.5 → 1.51.8

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

@@ -60,22 +60,29 @@ exports.BSTNode = BSTNode;
  */
 class BST extends binary_tree_1.BinaryTree {
     /**
-     * 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.
+     * This is the constructor function for a Binary Search Tree class in TypeScript, which initializes
+     * the tree with keys, nodes, or entries and optional options.
+     * @param keysOrNodesOrEntries - The `keysOrNodesOrEntries` parameter is an iterable object that can
+     * contain 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 = [], options) {
         super([], options);
-        this._variant = 'STANDARD';
+        this._root = undefined;
+        this._comparator = (a, b) => {
+            if (a > b)
+                return 1;
+            if (a < b)
+                return -1;
+            return 0;
+        };
         if (options) {
-            const { variant } = options;
-            if (variant)
-                this._variant = variant;
+            const { comparator } = options;
+            if (comparator)
+                this._comparator = comparator;
         }
-        this._root = undefined;
         if (keysOrNodesOrEntries)
             this.addMany(keysOrNodesOrEntries);
     }
@@ -87,11 +94,11 @@ class BST extends binary_tree_1.BinaryTree {
         return this._root;
     }
     /**
-     * The function returns the value of the _variant property.
-     * @returns The value of the `_variant` property.
+     * The function returns the value of the _comparator property.
+     * @returns The `_comparator` property is being returned.
      */
-    get variant() {
-        return this._variant;
+    get comparator() {
+        return this._comparator;
     }
     /**
      * The function creates a new BSTNode with the given key and value and returns it.
@@ -113,7 +120,7 @@ class BST extends binary_tree_1.BinaryTree {
      * options. The returned value is casted as TREE.
      */
     createTree(options) {
-        return new BST([], Object.assign({ iterationType: this.iterationType, variant: this.variant }, options));
+        return new BST([], Object.assign({ iterationType: this.iterationType, comparator: this.comparator }, options));
     }
     /**
      * The function `keyValueOrEntryToNode` takes an keyOrNodeOrEntry and returns a node if the keyOrNodeOrEntry is valid,
@@ -165,19 +172,21 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns either a node object (NODE) or undefined.
      */
     ensureNode(keyOrNodeOrEntry, iterationType = 'ITERATIVE') {
+        if (keyOrNodeOrEntry === this.NIL)
+            return;
         if (this.isRealNode(keyOrNodeOrEntry)) {
             return keyOrNodeOrEntry;
         }
-        else if (this.isEntry(keyOrNodeOrEntry)) {
-            if (keyOrNodeOrEntry[0] === null || keyOrNodeOrEntry[0] === undefined)
-                return;
-            return this.getNodeByKey(keyOrNodeOrEntry[0], iterationType);
-        }
-        else {
-            if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === undefined)
+        if (this.isEntry(keyOrNodeOrEntry)) {
+            const key = keyOrNodeOrEntry[0];
+            if (key === null || key === undefined)
                 return;
-            return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
+            return this.getNodeByKey(key, iterationType);
         }
+        const key = keyOrNodeOrEntry;
+        if (key === null || key === undefined)
+            return;
+        return this.getNodeByKey(key, iterationType);
     }
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
@@ -195,13 +204,11 @@ class BST extends binary_tree_1.BinaryTree {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * The `add` function adds a new node to a binary tree, updating the value if the key already exists
-     * or inserting a new node if the key is unique.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
-     * @param {V} [value] - The `value` parameter represents the value associated with the key that is
-     * being added to the binary tree.
-     * @returns The method `add` returns either the newly added node (`newNode`) or `undefined` if the
-     * node was not added.
+     * The `add` function in TypeScript adds a new node to a binary search tree based on the key value,
+     * updating the value if the key already exists.
+     * @param keyOrNodeOrEntry - It is a parameter that can accept three types of values:
+     * @param {V} [value] - The value to be added to the binary search tree.
+     * @returns The method returns a boolean value.
      */
     add(keyOrNodeOrEntry, value) {
         const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
@@ -214,7 +221,7 @@ class BST extends binary_tree_1.BinaryTree {
         }
         let current = this.root;
         while (current !== undefined) {
-            if (this._compare(current.key, newNode.key) === 'EQ') {
+            if (this.comparator(current.key, newNode.key) === 0) {
                 // if (current !== newNode) {
                 // The key value is the same but the reference is different, update the value of the existing node
                 this._replaceNode(current, newNode);
@@ -225,7 +232,7 @@ class BST extends binary_tree_1.BinaryTree {
                 //   return;
                 // }
             }
-            else if (this._compare(current.key, newNode.key) === 'GT') {
+            else if (this.comparator(current.key, newNode.key) > 0) {
                 if (current.left === undefined) {
                     current.left = newNode;
                     this._size++;
@@ -252,21 +259,24 @@ class BST extends binary_tree_1.BinaryTree {
      * Time Complexity: O(k log n)
      * Space Complexity: O(k + log n)
      *
-     * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
-     * balancing the tree after each addition.
-     * @param keysOrNodesOrEntries - An iterable containing the keys, nodes, or entries to be added to
-     * the binary tree.
+     * The `addMany` function in TypeScript adds multiple keys or nodes to a data structure, balancing
+     * the structure if specified, and returns an array indicating whether each key or node was
+     * successfully inserted.
+     * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries to be added to the
+     * data structure.
      * @param [values] - An optional iterable of values to be associated with the keys or nodes being
      * added. If provided, the values will be assigned to the corresponding keys or nodes in the same
      * order. If not provided, undefined will be assigned as the value for each key or node.
-     * @param [isBalanceAdd=true] - A boolean flag indicating whether the add operation should be
-     * balanced or not. If set to true, the add operation will be balanced using a binary search tree
-     * algorithm. If set to false, the add operation will not be balanced and the nodes will be added
-     * in the order they appear in the input.
-     * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-     * type of iteration to use when adding multiple keys or nodes. It has a default value of
-     * `this.iterationType`, which suggests that it is a property of the current object.
-     * @returns The function `addMany` returns an array of nodes (`NODE`) or `undefined` values.
+     * @param [isBalanceAdd=true] - A boolean flag indicating whether the tree should be balanced after
+     * adding the elements. If set to true, the tree will be balanced using a binary search tree
+     * algorithm. If set to false, the elements will be added without balancing the tree. The default
+     * value is true.
+     * @param {IterationType} iterationType - The `iterationType` parameter is an optional parameter that
+     * specifies the type of iteration to use when adding multiple keys or nodes to the binary tree. It
+     * has a default value of `this.iterationType`, which means it will use the iteration type specified
+     * in the binary tree instance.
+     * @returns The function `addMany` returns an array of booleans indicating whether each key or node
+     * or entry was successfully inserted into the data structure.
      */
     addMany(keysOrNodesOrEntries, values, isBalanceAdd = true, iterationType = this.iterationType) {
         const inserted = [];
@@ -293,20 +303,24 @@ class BST extends binary_tree_1.BinaryTree {
         }
         let sorted = [];
         sorted = realBTNExemplars.sort((a, b) => {
-            let aR, bR;
-            if (this.isEntry(a))
-                aR = this.extractor(a[0]);
+            let keyA, keyB;
+            if (this.isEntry(a)) {
+                keyA = a[0];
+            }
             else if (this.isRealNode(a))
-                aR = this.extractor(a.key);
+                keyA = a.key;
             else
-                aR = this.extractor(a);
+                keyA = a;
             if (this.isEntry(b))
-                bR = this.extractor(b[0]);
+                keyB = b[0];
             else if (this.isRealNode(b))
-                bR = this.extractor(b.key);
+                keyB = b.key;
             else
-                bR = this.extractor(b);
-            return aR - bR;
+                keyB = b;
+            if (keyA !== undefined && keyA !== null && keyB !== undefined && keyB !== null) {
+                return this.comparator(keyA, keyB);
+            }
+            return 0;
         });
         const _dfs = (arr) => {
             if (arr.length === 0)
@@ -342,56 +356,6 @@ class BST extends binary_tree_1.BinaryTree {
         }
         return inserted;
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
-     * either recursive or iterative methods.
-     * @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
-     * values:
-     * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
-     * found in the binary tree. If no node is found, it returns `undefined`.
-     */
-    getNodeByKey(key, iterationType = 'ITERATIVE') {
-        // return this.getNodes(key, this._DEFAULT_CALLBACK, true, this.root, iterationType)[0];
-        if (!this.isRealNode(this.root))
-            return;
-        if (iterationType === 'RECURSIVE') {
-            const dfs = (cur) => {
-                if (cur.key === key)
-                    return cur;
-                if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
-                    return;
-                if (this.isRealNode(cur.left) && this._compare(cur.key, key) === 'GT')
-                    return dfs(cur.left);
-                if (this.isRealNode(cur.right) && this._compare(cur.key, key) === 'LT')
-                    return dfs(cur.right);
-            };
-            return dfs(this.root);
-        }
-        else {
-            const stack = [this.root];
-            while (stack.length > 0) {
-                const cur = stack.pop();
-                if (this.isRealNode(cur)) {
-                    if (this._compare(cur.key, key) === 'EQ')
-                        return cur;
-                    if (this.isRealNode(cur.left) && this._compare(cur.key, key) === 'GT')
-                        stack.push(cur.left);
-                    if (this.isRealNode(cur.right) && this._compare(cur.key, key) === 'LT')
-                        stack.push(cur.right);
-                }
-            }
-        }
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(k + log n)
@@ -424,6 +388,7 @@ class BST extends binary_tree_1.BinaryTree {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
+        callback = this._ensureCallback(identifier, callback);
         const ans = [];
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
@@ -437,9 +402,9 @@ class BST extends binary_tree_1.BinaryTree {
                     return;
                 // TODO potential bug
                 if (callback === this._DEFAULT_CALLBACK) {
-                    if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === 'GT')
+                    if (this.isRealNode(cur.left) && this.comparator(cur.key, identifier) > 0)
                         dfs(cur.left);
-                    if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === 'LT')
+                    if (this.isRealNode(cur.right) && this.comparator(cur.key, identifier) < 0)
                         dfs(cur.right);
                 }
                 else {
@@ -453,30 +418,28 @@ class BST extends binary_tree_1.BinaryTree {
             const stack = [beginRoot];
             while (stack.length > 0) {
                 const cur = stack.pop();
-                if (this.isRealNode(cur)) {
-                    const callbackResult = callback(cur);
-                    if (callbackResult === identifier) {
-                        ans.push(cur);
-                        if (onlyOne)
-                            return ans;
-                    }
-                    // TODO potential bug
-                    if (callback === this._DEFAULT_CALLBACK) {
-                        if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === 'LT')
-                            stack.push(cur.right);
-                        if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === 'GT')
-                            stack.push(cur.left);
-                        // if (this.isRealNode(cur.right) && this._lt(cur.key, identifier as K)) stack.push(cur.right);
-                        // if (this.isRealNode(cur.left) && this._gt(cur.key, identifier as K)) stack.push(cur.left);
-                        // // @ts-ignore
-                        // if (this.isRealNode(cur.right) && cur.key > identifier) stack.push(cur.right);
-                        // // @ts-ignore
-                        // if (this.isRealNode(cur.left) && cur.key < identifier) stack.push(cur.left);
-                    }
-                    else {
-                        this.isRealNode(cur.right) && stack.push(cur.right);
-                        this.isRealNode(cur.left) && stack.push(cur.left);
-                    }
+                const callbackResult = callback(cur);
+                if (callbackResult === identifier) {
+                    ans.push(cur);
+                    if (onlyOne)
+                        return ans;
+                }
+                // TODO potential bug
+                if (callback === this._DEFAULT_CALLBACK) {
+                    if (this.isRealNode(cur.right) && this.comparator(cur.key, identifier) < 0)
+                        stack.push(cur.right);
+                    if (this.isRealNode(cur.left) && this.comparator(cur.key, identifier) > 0)
+                        stack.push(cur.left);
+                    // if (this.isRealNode(cur.right) && this._lt(cur.key, identifier as K)) stack.push(cur.right);
+                    // if (this.isRealNode(cur.left) && this._gt(cur.key, identifier as K)) stack.push(cur.left);
+                    // // @ts-ignore
+                    // if (this.isRealNode(cur.right) && cur.key > identifier) stack.push(cur.right);
+                    // // @ts-ignore
+                    // if (this.isRealNode(cur.left) && cur.key < identifier) stack.push(cur.left);
+                }
+                else {
+                    this.isRealNode(cur.right) && stack.push(cur.right);
+                    this.isRealNode(cur.left) && stack.push(cur.left);
                 }
             }
         }
@@ -511,6 +474,27 @@ class BST extends binary_tree_1.BinaryTree {
         var _a;
         return (_a = this.getNodes(identifier, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : undefined;
     }
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
+     *
+     * The function `getNodeByKey` searches for a node in a binary tree based on a given key, using
+     * either recursive or iterative methods.
+     * @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
+     * values:
+     * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
+     * found in the binary tree. If no node is found, it returns `undefined`.
+     */
+    getNodeByKey(key, iterationType = 'ITERATIVE') {
+        return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)
@@ -586,41 +570,6 @@ class BST extends binary_tree_1.BinaryTree {
     listLevels(callback = this._DEFAULT_CALLBACK, beginRoot = this.root, iterationType = this.iterationType) {
         return super.listLevels(callback, beginRoot, iterationType, false);
     }
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(log n)
-     * Space Complexity: O(1)
-     *
-     * 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 | NODE | undefined} beginRoot - The `beginRoot` parameter is optional and can be of
-     * type `K`, `NODE`, 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`).
-     * @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) {
-        let current = this.ensureNode(beginRoot);
-        if (!current)
-            return undefined;
-        if (this._variant === 'STANDARD') {
-            // For 'STANDARD', find the rightmost node
-            while (current.right !== undefined) {
-                current = current.right;
-            }
-        }
-        else {
-            // For BSTVariant.MAX, find the leftmost node
-            while (current.left !== undefined) {
-                current = current.left;
-            }
-        }
-        return current.key;
-    }
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(log n)
@@ -646,18 +595,18 @@ class BST extends binary_tree_1.BinaryTree {
      * @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(callback = this._DEFAULT_CALLBACK, lesserOrGreater = 'LT', targetNode = this.root, iterationType = this.iterationType) {
-        targetNode = this.ensureNode(targetNode);
+    lesserOrGreaterTraverse(callback = this._DEFAULT_CALLBACK, lesserOrGreater = -1, targetNode = this.root, iterationType = this.iterationType) {
+        const targetNodeEnsured = this.ensureNode(targetNode);
         const ans = [];
-        if (!targetNode)
+        if (!targetNodeEnsured)
             return ans;
         if (!this.root)
             return ans;
-        const targetKey = targetNode.key;
+        const targetKey = targetNodeEnsured.key;
         if (iterationType === 'RECURSIVE') {
             const dfs = (cur) => {
-                const compared = this._compare(cur.key, targetKey);
-                if (compared === lesserOrGreater)
+                const compared = this.comparator(cur.key, targetKey);
+                if (Math.sign(compared) === lesserOrGreater)
                     ans.push(callback(cur));
                 if (this.isRealNode(cur.left))
                     dfs(cur.left);
@@ -672,8 +621,8 @@ class BST extends binary_tree_1.BinaryTree {
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (this.isRealNode(cur)) {
-                    const compared = this._compare(cur.key, targetKey);
-                    if (compared === lesserOrGreater)
+                    const compared = this.comparator(cur.key, targetKey);
+                    if (Math.sign(compared) === lesserOrGreater)
                         ans.push(callback(cur));
                     if (this.isRealNode(cur.left))
                         queue.push(cur.left);
@@ -814,52 +763,5 @@ class BST extends binary_tree_1.BinaryTree {
         }
         this._root = v;
     }
-    /**
-     * 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 {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 'GT' (greater
-     * than), 'LT' (less than), or 'EQ' (equal).
-     */
-    _compare(a, b) {
-        const extractedA = this.extractor(a);
-        const extractedB = this.extractor(b);
-        const compared = this.variant === 'STANDARD' ? extractedA - extractedB : extractedB - extractedA;
-        return compared > 0 ? 'GT' : compared < 0 ? 'LT' : 'EQ';
-    }
-    /**
-     * The function `_lt` compares two values `a` and `b` using an extractor function and returns true if
-     * `a` is less than `b` based on the specified variant.
-     * @param {K} a - The parameter "a" is of type "K", which means it can be any type. It represents the
-     * first value to be compared in the function.
-     * @param {K} b - The parameter `b` is of type `K`, which means it can be any type. It is used as one
-     * of the arguments for the comparison in the `_lt` function.
-     * @returns a boolean value.
-     */
-    _lt(a, b) {
-        const extractedA = this.extractor(a);
-        const extractedB = this.extractor(b);
-        // return this.variant === BSTVariant.STANDARD ? extractedA < extractedB : extractedA > extractedB;
-        return this.variant === 'STANDARD' ? extractedA < extractedB : extractedA > extractedB;
-        // return extractedA < extractedB;
-        // return a < b;
-    }
-    /**
-     * The function compares two values using a custom extractor function and returns true if the first
-     * value is greater than the second value.
-     * @param {K} a - The parameter "a" is of type K, which means it can be any type.
-     * @param {K} b - The parameter "b" is of type K, which means it can be any type. It is used as one
-     * of the arguments for the comparison in the function.
-     * @returns a boolean value.
-     */
-    _gt(a, b) {
-        const extractedA = this.extractor(a);
-        const extractedB = this.extractor(b);
-        // return this.variant === BSTVariant.STANDARD  ? extractedA > extractedB : extractedA < extractedB;
-        return this.variant === 'STANDARD' ? extractedA > extractedB : extractedA < extractedB;
-        // return extractedA > extractedB;
-        // return a > b;
-    }
 }
 exports.BST = BST;

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

@@ -1,8 +1,7 @@
-import type { BinaryTreeDeleteResult, BTNCallback, KeyOrNodeOrEntry, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
-import { CRUD, RBTNColor } from '../../types';
+import type { BinaryTreeDeleteResult, BTNCallback, Comparable, CRUD, KeyOrNodeOrEntry, RBTNColor, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 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> {
+export declare class RedBlackTreeNode<K extends Comparable, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
     /**
      * The constructor function initializes a Red-Black Tree Node with a key, an optional value, and a
      * color.
@@ -27,7 +26,7 @@ export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTre
      */
     set color(value: RBTNColor);
 }
-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> {
+export declare class RedBlackTree<K extends Comparable, 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> {
     /**
      * This is the constructor function for a Red-Black Tree data structure in TypeScript.
      * @param keysOrNodesOrEntries - The `keysOrNodesOrEntries` parameter is an iterable object that can

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

@@ -214,6 +214,7 @@ class RedBlackTree extends bst_1.BST {
         if (identifier === null)
             return [];
         const results = [];
+        callback = this._ensureCallback(identifier, callback);
         const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
         if (!nodeToDelete) {
             return results;
@@ -313,10 +314,11 @@ class RedBlackTree extends bst_1.BST {
         let parent = undefined;
         while (this.isRealNode(current)) {
             parent = current;
-            if (node.key < current.key) {
+            const compared = this.comparator(node.key, current.key);
+            if (compared < 0) {
                 current = (_a = current.left) !== null && _a !== void 0 ? _a : this.NIL;
             }
-            else if (node.key > current.key) {
+            else if (compared > 0) {
                 current = (_b = current.right) !== null && _b !== void 0 ? _b : this.NIL;
             }
             else {

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

@@ -5,11 +5,10 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
-import { RBTNColor } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, Comparable, IterationType, KeyOrNodeOrEntry, RBTNColor, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
-export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
+export declare class TreeMultiMapNode<K extends Comparable, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>> extends RedBlackTreeNode<K, V, NODE> {
     /**
      * The constructor function initializes a Red-Black Tree node with a key, value, count, and color.
      * @param {K} key - The key parameter represents the key of the node in the Red-Black Tree. It is
@@ -36,7 +35,7 @@ export declare class TreeMultiMapNode<K = any, V = any, NODE extends TreeMultiMa
      */
     set count(value: number);
 }
-export declare class TreeMultiMap<K = any, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>, TREE extends TreeMultiMap<K, V, NODE, TREE> = TreeMultiMap<K, V, NODE, TreeMultiMapNested<K, V, NODE>>> extends RedBlackTree<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
+export declare class TreeMultiMap<K extends Comparable, V = any, NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNode<K, V, TreeMultiMapNodeNested<K, V>>, TREE extends TreeMultiMap<K, V, NODE, TREE> = TreeMultiMap<K, V, NODE, TreeMultiMapNested<K, V, NODE>>> extends RedBlackTree<K, V, NODE, TREE> implements IBinaryTree<K, V, NODE, TREE> {
     /**
      * The constructor function initializes a new instance of the TreeMultiMap class with optional
      * initial keys, nodes, or entries.

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

@@ -210,6 +210,7 @@ class TreeMultiMap extends rb_tree_1.RedBlackTree {
         if (identifier === null)
             return [];
         const results = [];
+        callback = this._ensureCallback(identifier, callback);
         const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
         if (!nodeToDelete) {
             return results;

package/dist/data-structures/heap/heap.d.ts

@@ -57,9 +57,7 @@ export declare class Heap<E = any> extends IterableElementBase<E> {
      * @param elements
      * @param options
      */
-    static heapify<E>(elements: Iterable<E>, options: {
-        comparator: Comparator<E>;
-    }): Heap<E>;
+    static heapify<E>(elements: Iterable<E>, options: HeapOptions<E>): Heap<E>;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)

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

@@ -1,8 +1,8 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, KeyOrNodeOrEntry } 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>> {
+import type { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, Comparable, KeyOrNodeOrEntry } from '../types';
+export interface IBinaryTree<K extends Comparable, 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;
+    createTree(options?: Partial<BinaryTreeOptions>): TREE;
     add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V, count?: number): boolean;
     addMany(nodes: Iterable<KeyOrNodeOrEntry<K, V, N>>, values?: Iterable<V | undefined>): boolean[];
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<N>[];

package/dist/types/common.d.ts

@@ -1,5 +1,5 @@
 export type BSTVariant = 'STANDARD' | 'INVERSE';
-export type CP = 'LT' | 'EQ' | 'GT';
+export type CP = 1 | -1 | 0;
 /**
  * Enum representing different loop types.
  *

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

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