bst-typed 1.51.5 → 1.51.8

package/src/data-structures/binary-tree/bst.ts

@@ -7,22 +7,27 @@
  */
 import type {
   BSTNested,
+  BSTNKeyOrNode,
   BSTNodeNested,
   BSTOptions,
   BTNCallback,
   BTNodePureExemplar,
+  Comparable,
+  Comparator,
+  CP,
+  DFSOrderPattern,
+  IterationType,
   KeyOrNodeOrEntry
 } from '../../types';
-import { BSTNKeyOrNode, BSTVariant, CP, DFSOrderPattern, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Queue } from '../queue';
 
-export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNodeNested<K, V>> extends BinaryTreeNode<
-  K,
-  V,
-  NODE
-> {
+export class BSTNode<
+  K extends Comparable,
+  V = any,
+  NODE extends BSTNode<K, V, NODE> = BSTNodeNested<K, V>
+> extends BinaryTreeNode<K, V, NODE> {
   override parent?: NODE;
 
   constructor(key: K, value?: V) {
@@ -88,7 +93,7 @@ export class BSTNode<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BSTNod
  * 7. No Auto-Balancing: Standard BSTs don't automatically balance themselves.
  */
 export class BST<
-  K = any,
+  K extends Comparable,
   V = any,
   NODE extends BSTNode<K, V, NODE> = BSTNode<K, V, BSTNodeNested<K, V>>,
   TREE extends BST<K, V, NODE, TREE> = BST<K, V, NODE, BSTNested<K, V, NODE>>
@@ -96,10 +101,11 @@ export class BST<
   extends BinaryTree<K, V, NODE, TREE>
   implements IBinaryTree<K, V, NODE, TREE> {
   /**
-   * This is the constructor function for a TypeScript class that initializes a binary search tree with
-   * optional keys or nodes or entries and options.
-   * @param keysOrNodesOrEntries - An iterable object that contains keys, nodes, or entries. It is used
-   * to initialize the binary search tree with the provided keys, nodes, or entries.
+   * 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:
    */
@@ -107,16 +113,14 @@ export class BST<
     super([], options);
 
     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);
   }
 
-  protected override _root?: NODE;
+  protected override _root?: NODE = undefined;
 
   /**
    * The function returns the root node of a tree structure.
@@ -126,14 +130,18 @@ export class BST<
     return this._root;
   }
 
-  protected _variant: BSTVariant = 'STANDARD';
+  protected _comparator: Comparator<K> = (a: K, b: K): CP => {
+    if (a > b) return 1;
+    if (a < b) return -1;
+    return 0;
+  };
 
   /**
-   * 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;
   }
 
   /**
@@ -159,7 +167,7 @@ export class BST<
   override createTree(options?: Partial<BSTOptions<K>>): TREE {
     return new BST<K, V, NODE, TREE>([], {
       iterationType: this.iterationType,
-      variant: this.variant,
+      comparator: this.comparator,
       ...options
     }) as TREE;
   }
@@ -214,15 +222,20 @@ export class BST<
     keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
     iterationType: IterationType = 'ITERATIVE'
   ): NODE | undefined {
+    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) return;
-      return this.getNodeByKey(keyOrNodeOrEntry, iterationType);
     }
+
+    if (this.isEntry(keyOrNodeOrEntry)) {
+      const key = keyOrNodeOrEntry[0];
+      if (key === null || key === undefined) return;
+      return this.getNodeByKey(key, iterationType);
+    }
+
+    const key = keyOrNodeOrEntry;
+    if (key === null || key === undefined) return;
+    return this.getNodeByKey(key, iterationType);
   }
 
   /**
@@ -243,13 +256,11 @@ export class BST<
    * 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.
    */
   override add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, value?: V): boolean {
     const newNode = this.keyValueOrEntryToNode(keyOrNodeOrEntry, value);
@@ -263,7 +274,7 @@ export class BST<
 
     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);
@@ -275,7 +286,7 @@ export class BST<
 
         //   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++;
@@ -304,21 +315,24 @@ export class BST<
    * 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.
    */
   override addMany(
     keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>>,
@@ -357,16 +371,20 @@ export class BST<
     let sorted: BTNodePureExemplar<K, V, NODE>[] = [];
 
     sorted = realBTNExemplars.sort((a, b) => {
-      let aR: number, bR: number;
-      if (this.isEntry(a)) aR = this.extractor(a[0]);
-      else if (this.isRealNode(a)) aR = this.extractor(a.key);
-      else aR = this.extractor(a);
-
-      if (this.isEntry(b)) bR = this.extractor(b[0]);
-      else if (this.isRealNode(b)) bR = this.extractor(b.key);
-      else bR = this.extractor(b);
-
-      return aR - bR;
+      let keyA: K | undefined | null, keyB: K | undefined | null;
+      if (this.isEntry(a)) {
+        keyA = a[0];
+      } else if (this.isRealNode(a)) keyA = a.key;
+      else keyA = a;
+
+      if (this.isEntry(b)) keyB = b[0];
+      else if (this.isRealNode(b)) keyB = b.key;
+      else keyB = b;
+
+      if (keyA !== undefined && keyA !== null && keyB !== undefined && keyB !== null) {
+        return this.comparator(keyA, keyB);
+      }
+      return 0;
     });
 
     const _dfs = (arr: BTNodePureExemplar<K, V, NODE>[]) => {
@@ -406,51 +424,6 @@ export class BST<
     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`.
-   */
-  override getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
-    // return this.getNodes(key, this._DEFAULT_CALLBACK, true, this.root, iterationType)[0];
-    if (!this.isRealNode(this.root)) return;
-    if (iterationType === 'RECURSIVE') {
-      const dfs = (cur: NODE): NODE | undefined => {
-        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)
@@ -488,6 +461,7 @@ export class BST<
   ): NODE[] {
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return [];
+    callback = this._ensureCallback(identifier, callback);
     const ans: NODE[] = [];
 
     if (iterationType === 'RECURSIVE') {
@@ -501,8 +475,8 @@ export class BST<
         if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
         // TODO potential bug
         if (callback === this._DEFAULT_CALLBACK) {
-          if (this.isRealNode(cur.left) && this._compare(cur.key, identifier as K) === 'GT') dfs(cur.left);
-          if (this.isRealNode(cur.right) && this._compare(cur.key, identifier as K) === 'LT') dfs(cur.right);
+          if (this.isRealNode(cur.left) && this.comparator(cur.key, identifier as K) > 0) dfs(cur.left);
+          if (this.isRealNode(cur.right) && this.comparator(cur.key, identifier as K) < 0) dfs(cur.right);
         } else {
           this.isRealNode(cur.left) && dfs(cur.left);
           this.isRealNode(cur.right) && dfs(cur.right);
@@ -513,29 +487,27 @@ export class BST<
     } else {
       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 as K) === 'LT') stack.push(cur.right);
-            if (this.isRealNode(cur.left) && this._compare(cur.key, identifier as K) === '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 cur = stack.pop()!;
+        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 as K) < 0) stack.push(cur.right);
+          if (this.isRealNode(cur.left) && this.comparator(cur.key, identifier as K) > 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);
         }
       }
     }
@@ -578,6 +550,29 @@ export class BST<
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? 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`.
+   */
+  override getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
+    return this.getNode(key, this._DEFAULT_CALLBACK, this.root, iterationType);
+  }
+
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)
@@ -672,42 +667,6 @@ export class BST<
     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: KeyOrNodeOrEntry<K, V, NODE> = this.root): K | undefined {
-    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)
@@ -736,21 +695,21 @@ export class BST<
    */
   lesserOrGreaterTraverse<C extends BTNCallback<NODE>>(
     callback: C = this._DEFAULT_CALLBACK as C,
-    lesserOrGreater: CP = 'LT',
+    lesserOrGreater: CP = -1,
     targetNode: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
-    targetNode = this.ensureNode(targetNode);
+    const targetNodeEnsured = this.ensureNode(targetNode);
     const ans: ReturnType<BTNCallback<NODE>>[] = [];
-    if (!targetNode) return ans;
+    if (!targetNodeEnsured) return ans;
     if (!this.root) return ans;
 
-    const targetKey = targetNode.key;
+    const targetKey = targetNodeEnsured.key;
 
     if (iterationType === 'RECURSIVE') {
       const dfs = (cur: NODE) => {
-        const compared = this._compare(cur.key, targetKey);
-        if (compared === lesserOrGreater) ans.push(callback(cur));
+        const compared = this.comparator(cur.key, targetKey);
+        if (Math.sign(compared) === lesserOrGreater) ans.push(callback(cur));
 
         if (this.isRealNode(cur.left)) dfs(cur.left);
         if (this.isRealNode(cur.right)) dfs(cur.right);
@@ -763,8 +722,8 @@ export class BST<
       while (queue.size > 0) {
         const cur = queue.shift();
         if (this.isRealNode(cur)) {
-          const compared = this._compare(cur.key, targetKey);
-          if (compared === lesserOrGreater) ans.push(callback(cur));
+          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);
           if (this.isRealNode(cur.right)) queue.push(cur.right);
@@ -906,55 +865,4 @@ export class BST<
     }
     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).
-   */
-  protected _compare(a: K, b: K): CP {
-    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.
-   */
-  protected _lt(a: K, b: K): boolean {
-    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.
-   */
-  protected _gt(a: K, b: K): boolean {
-    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;
-  }
 }

package/src/data-structures/binary-tree/rb-tree.ts

@@ -1,17 +1,19 @@
 import type {
   BinaryTreeDeleteResult,
   BTNCallback,
+  Comparable,
+  CRUD,
   KeyOrNodeOrEntry,
+  RBTNColor,
   RBTreeOptions,
   RedBlackTreeNested,
   RedBlackTreeNodeNested
 } from '../../types';
-import { CRUD, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 
 export class RedBlackTreeNode<
-  K = any,
+  K extends Comparable,
   V = any,
   NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>
 > extends BSTNode<K, V, NODE> {
@@ -51,7 +53,7 @@ export class RedBlackTreeNode<
 }
 
 export class RedBlackTree<
-  K = any,
+  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>>
@@ -252,7 +254,7 @@ export class RedBlackTree<
   ): BinaryTreeDeleteResult<NODE>[] {
     if (identifier === null) return [];
     const results: BinaryTreeDeleteResult<NODE>[] = [];
-
+    callback = this._ensureCallback(identifier, callback);
     const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
 
     if (!nodeToDelete) {
@@ -363,9 +365,10 @@ export class RedBlackTree<
 
     while (this.isRealNode(current)) {
       parent = current;
-      if (node.key < current.key) {
+      const compared = this.comparator(node.key, current.key);
+      if (compared < 0) {
         current = current.left ?? this.NIL;
-      } else if (node.key > current.key) {
+      } else if (compared > 0) {
         current = current.right ?? this.NIL;
       } else {
         this._replaceNode(current, node);

package/src/data-structures/binary-tree/tree-multi-map.ts

@@ -9,18 +9,19 @@ import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNCallback,
+  Comparable,
   IterationType,
   KeyOrNodeOrEntry,
+  RBTNColor,
   TreeMultiMapNested,
   TreeMultiMapNodeNested,
   TreeMultiMapOptions
 } from '../../types';
-import { RBTNColor } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { RedBlackTree, RedBlackTreeNode } from './rb-tree';
 
 export class TreeMultiMapNode<
-  K = any,
+  K extends Comparable,
   V = any,
   NODE extends TreeMultiMapNode<K, V, NODE> = TreeMultiMapNodeNested<K, V>
 > extends RedBlackTreeNode<K, V, NODE> {
@@ -62,7 +63,7 @@ export class TreeMultiMapNode<
 }
 
 export class TreeMultiMap<
-  K = any,
+  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>>
@@ -257,6 +258,7 @@ export class TreeMultiMap<
   ): BinaryTreeDeleteResult<NODE>[] {
     if (identifier === null) return [];
     const results: BinaryTreeDeleteResult<NODE>[] = [];
+    callback = this._ensureCallback(identifier, callback);
 
     const nodeToDelete = this.isRealNode(identifier) ? identifier : this.getNode(identifier, callback);
 

package/src/data-structures/heap/heap.ts

@@ -93,7 +93,7 @@ export 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> {
     return new Heap<E>(elements, options);
   }
 

package/src/interfaces/binary-tree.ts

@@ -1,22 +1,23 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import {
+import type {
   BinaryTreeDeleteResult,
   BinaryTreeNested,
   BinaryTreeNodeNested,
   BinaryTreeOptions,
   BTNCallback,
+  Comparable,
   KeyOrNodeOrEntry
 } from '../types';
 
 export interface IBinaryTree<
-  K = number,
+  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;
 

package/src/types/common.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.