data-structure-typed 1.50.6 → 1.50.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.50.6",
+  "version": "1.50.8",
   "description": "Javascript Data Structure. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java.util. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
@@ -66,11 +66,11 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.44.0",
+    "avl-tree-typed": "^1.50.7",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.44.0",
-    "bst-typed": "^1.44.0",
-    "data-structure-typed": "^1.44.0",
+    "binary-tree-typed": "^1.50.7",
+    "bst-typed": "^1.50.7",
+    "data-structure-typed": "^1.50.7",
     "dependency-cruiser": "^14.1.0",
     "doctoc": "^2.2.1",
     "eslint": "^8.50.0",
@@ -79,7 +79,7 @@
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
     "fast-glob": "^3.3.1",
-    "heap-typed": "^1.44.0",
+    "heap-typed": "^1.50.7",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "js-sdsl": "^4.4.2",

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

@@ -14,7 +14,6 @@ import type {
   BTNCallback,
   KeyOrNodeOrEntry
 } from '../../types';
-import { FamilyPosition, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 
@@ -83,6 +82,10 @@ export class AVLTreeMultiMap<
    * @returns the sum of the count property of all nodes in the tree.
    */
   get count(): number {
+    return this._count;
+  }
+
+  getMutableCount(): number {
     let sum = 0;
     this.dfs(node => (sum += node.count));
     return sum;
@@ -245,9 +248,9 @@ export class AVLTreeMultiMap<
           if (curr.right !== undefined) this._setRoot(curr.right);
         } else {
           const { familyPosition: fp } = curr;
-          if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
+          if (fp === 'LEFT' || fp === 'ROOT_LEFT') {
             parent.left = curr.right;
-          } else if (fp === FamilyPosition.RIGHT || fp === FamilyPosition.ROOT_RIGHT) {
+          } else if (fp === 'RIGHT' || fp === 'ROOT_RIGHT') {
             parent.right = curr.right;
           }
           needBalanced = parent;
@@ -320,7 +323,7 @@ export class AVLTreeMultiMap<
 
     this.clear();
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const buildBalanceBST = (l: number, r: number) => {
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);
@@ -414,7 +417,7 @@ export class AVLTreeMultiMap<
    * @returns The method is returning the result of calling the `_replaceNode` method from the
    * superclass, after updating the `count` property of the `newNode` object.
    */
-  protected _replaceNode(oldNode: NODE, newNode: NODE): NODE {
+  protected override _replaceNode(oldNode: NODE, newNode: NODE): NODE {
     newNode.count = oldNode.count + newNode.count;
     return super._replaceNode(oldNode, newNode);
   }

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

@@ -522,7 +522,7 @@ export class AVLTree<
    * @returns the result of calling the `_replaceNode` method on the superclass, passing in the
    * `oldNode` and `newNode` as arguments.
    */
-  protected _replaceNode(oldNode: NODE, newNode: NODE): NODE {
+  protected override _replaceNode(oldNode: NODE, newNode: NODE): NODE {
     newNode.height = oldNode.height;
 
     return super._replaceNode(oldNode, newNode);

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

@@ -107,16 +107,16 @@ export class BinaryTreeNode<
   get familyPosition(): FamilyPosition {
     const that = this as unknown as NODE;
     if (!this.parent) {
-      return this.left || this.right ? FamilyPosition.ROOT : FamilyPosition.ISOLATED;
+      return this.left || this.right ? 'ROOT' : 'ISOLATED';
     }
 
     if (this.parent.left === that) {
-      return this.left || this.right ? FamilyPosition.ROOT_LEFT : FamilyPosition.LEFT;
+      return this.left || this.right ? 'ROOT_LEFT' : 'LEFT';
     } else if (this.parent.right === that) {
-      return this.left || this.right ? FamilyPosition.ROOT_RIGHT : FamilyPosition.RIGHT;
+      return this.left || this.right ? 'ROOT_RIGHT' : 'RIGHT';
     }
 
-    return FamilyPosition.MAL_NODE;
+    return 'MAL_NODE';
   }
 }
 
@@ -136,7 +136,7 @@ export class BinaryTree<
 >
   extends IterableEntryBase<K, V | undefined>
   implements IBinaryTree<K, V, NODE, TREE> {
-  iterationType = IterationType.ITERATIVE;
+  iterationType: IterationType = 'ITERATIVE';
 
   /**
    * The constructor function initializes a binary tree object with optional keysOrNodesOrEntries and options.
@@ -160,7 +160,7 @@ export class BinaryTree<
     if (keysOrNodesOrEntries) this.addMany(keysOrNodesOrEntries);
   }
 
-  protected _extractor = (key: K) => Number(key);
+  protected _extractor = (key: K) => (typeof key === 'number' ? key : Number(key));
 
   /**
    * The function returns the value of the `_extractor` property.
@@ -260,14 +260,11 @@ export class BinaryTree<
    * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
    * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
    * type of iteration to be used when searching for a node by key. It has a default value of
-   * `IterationType.ITERATIVE`.
+   * `'ITERATIVE'`.
    * @returns either the node corresponding to the given key if it is a valid node key, or the key
    * itself if it is not a valid node key.
    */
-  ensureNode(
-    keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
-    iterationType = IterationType.ITERATIVE
-  ): NODE | null | undefined {
+  ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType = 'ITERATIVE'): NODE | null | undefined {
     let res: NODE | null | undefined;
     if (this.isRealNode(keyOrNodeOrEntry)) {
       res = keyOrNodeOrEntry;
@@ -521,9 +518,9 @@ export class BinaryTree<
       }
     } else if (parent) {
       const { familyPosition: fp } = curr;
-      if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
+      if (fp === 'LEFT' || fp === 'ROOT_LEFT') {
         parent.left = curr.right;
-      } else if (fp === FamilyPosition.RIGHT || fp === FamilyPosition.ROOT_RIGHT) {
+      } else if (fp === 'RIGHT' || fp === 'ROOT_RIGHT') {
         parent.right = curr.right;
       }
       needBalanced = parent;
@@ -606,7 +603,7 @@ export class BinaryTree<
 
     const ans: NODE[] = [];
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _traverse = (cur: NODE) => {
         if (callback(cur) === identifier) {
           ans.push(cur);
@@ -714,9 +711,9 @@ export class BinaryTree<
    * @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: K, iterationType = IterationType.ITERATIVE): NODE | undefined {
+  getNodeByKey(key: K, iterationType = 'ITERATIVE'): NODE | undefined {
     if (!this.root) return undefined;
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _dfs = (cur: NODE): NODE | undefined => {
         if (cur.key === key) return cur;
 
@@ -932,7 +929,7 @@ export class BinaryTree<
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return true;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const dfs = (cur: NODE | null | undefined, min: number, max: number): boolean => {
         if (!this.isRealNode(cur)) return true;
         const numKey = this.extractor(cur.key);
@@ -1021,9 +1018,9 @@ export class BinaryTree<
    */
   getHeight(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, iterationType = this.iterationType): number {
     beginRoot = this.ensureNode(beginRoot);
-    if (!beginRoot) return -1;
+    if (!this.isRealNode(beginRoot)) return -1;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _getMaxHeight = (cur: NODE | null | undefined): number => {
         if (!this.isRealNode(cur)) return -1;
         const leftHeight = _getMaxHeight(cur.left);
@@ -1071,10 +1068,10 @@ export class BinaryTree<
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return -1;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _getMinHeight = (cur: NODE | null | undefined): number => {
-        if (!cur) return 0;
-        if (!cur.left && !cur.right) return 0;
+        if (!this.isRealNode(cur)) return 0;
+        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return 0;
         const leftMinHeight = _getMinHeight(cur.left);
         const rightMinHeight = _getMinHeight(cur.right);
         return Math.min(leftMinHeight, rightMinHeight) + 1;
@@ -1088,16 +1085,16 @@ export class BinaryTree<
       const depths: Map<NODE, number> = new Map();
 
       while (stack.length > 0 || node) {
-        if (node) {
+        if (this.isRealNode(node)) {
           stack.push(node);
           node = node.left;
         } else {
           node = stack[stack.length - 1];
-          if (!node.right || last === node.right) {
+          if (!this.isRealNode(node.right) || last === node.right) {
             node = stack.pop();
-            if (node) {
-              const leftMinHeight = node.left ? depths.get(node.left) ?? -1 : -1;
-              const rightMinHeight = node.right ? depths.get(node.right) ?? -1 : -1;
+            if (this.isRealNode(node)) {
+              const leftMinHeight = this.isRealNode(node.left) ? depths.get(node.left) ?? -1 : -1;
+              const rightMinHeight = this.isRealNode(node.right) ? depths.get(node.right) ?? -1 : -1;
               depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
               last = node;
               node = null;
@@ -1169,11 +1166,12 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType = this.iterationType
   ): NODE | null | undefined {
+    if (this.isNIL(beginRoot)) return beginRoot as NODE;
     beginRoot = this.ensureNode(beginRoot);
 
-    if (!beginRoot) return beginRoot;
+    if (!this.isRealNode(beginRoot)) return beginRoot;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _traverse = (cur: NODE): NODE => {
         if (!this.isRealNode(cur.left)) return cur;
         return _traverse(cur.left);
@@ -1215,11 +1213,12 @@ export class BinaryTree<
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType = this.iterationType
   ): NODE | null | undefined {
+    if (this.isNIL(beginRoot)) return beginRoot as NODE;
     // TODO support get right most by passing key in
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return beginRoot;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _traverse = (cur: NODE): NODE => {
         if (!this.isRealNode(cur.right)) return cur;
         return _traverse(cur.right);
@@ -1343,13 +1342,13 @@ export class BinaryTree<
     callback: C = this._defaultOneParamCallback as C,
     pattern: DFSOrderPattern = 'in',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType: IterationType = IterationType.ITERATIVE,
+    iterationType: IterationType = 'ITERATIVE',
     includeNull = false
   ): ReturnType<C>[] {
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return [];
     const ans: ReturnType<C>[] = [];
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _traverse = (node: NODE | null | undefined) => {
         switch (pattern) {
           case 'in':
@@ -1485,7 +1484,7 @@ export class BinaryTree<
 
     const ans: ReturnType<BTNCallback<NODE>>[] = [];
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const queue: Queue<NODE | null | undefined> = new Queue<NODE | null | undefined>([beginRoot]);
 
       const traverse = (level: number) => {
@@ -1578,7 +1577,7 @@ export class BinaryTree<
     const levelsNodes: ReturnType<C>[][] = [];
     if (!beginRoot) return levelsNodes;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _recursive = (node: NODE | null, level: number) => {
         if (!levelsNodes[level]) levelsNodes[level] = [];
         levelsNodes[level].push(callback(node));
@@ -1837,7 +1836,7 @@ export class BinaryTree<
    * following types:
    * @param {BinaryTreePrintOptions} [options={ isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false}] - Options object that controls printing behavior. You can specify whether to display undefined, null, or sentinel nodes.
    */
-  print(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, options?: BinaryTreePrintOptions): void {
+  override print(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, options?: BinaryTreePrintOptions): void {
     const opts = { isShowUndefined: false, isShowNull: false, isShowRedBlackNIL: false, ...options };
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return;
@@ -1874,7 +1873,7 @@ export class BinaryTree<
   protected* _getIterator(node = this.root): IterableIterator<[K, V | undefined]> {
     if (!node) return;
 
-    if (this.iterationType === IterationType.ITERATIVE) {
+    if (this.iterationType === 'ITERATIVE') {
       const stack: (NODE | null | undefined)[] = [];
       let current: NODE | null | undefined = node;
 

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

@@ -126,7 +126,7 @@ export class BST<
     return this._root;
   }
 
-  protected _variant = BSTVariant.STANDARD;
+  protected _variant: BSTVariant = 'STANDARD';
 
   /**
    * The function returns the value of the _variant property.
@@ -207,13 +207,10 @@ export class BST<
    * @param {K | NODE | undefined} keyOrNodeOrEntry - The `key` parameter can be of type `K`, `NODE`, 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`.
+   * type of iteration to be performed. It has a default value of `'ITERATIVE'`.
    * @returns either a node object (NODE) or undefined.
    */
-  override ensureNode(
-    keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
-    iterationType = IterationType.ITERATIVE
-  ): NODE | undefined {
+  override ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType = 'ITERATIVE'): NODE | undefined {
     let res: NODE | undefined;
     if (this.isRealNode(keyOrNodeOrEntry)) {
       res = keyOrNodeOrEntry;
@@ -263,7 +260,7 @@ export class BST<
 
     let current = this.root;
     while (current !== undefined) {
-      if (this._compare(current.key, newNode.key) === CP.eq) {
+      if (this._compare(current.key, newNode.key) === 'EQ') {
         // 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 +272,7 @@ export class BST<
 
         //   return;
         // }
-      } else if (this._compare(current.key, newNode.key) === CP.gt) {
+      } else if (this._compare(current.key, newNode.key) === 'GT') {
         if (current.left === undefined) {
           current.left = newNode;
           this._size++;
@@ -397,7 +394,7 @@ export class BST<
       }
     };
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       _dfs(sorted);
     } else {
       _iterate();
@@ -425,15 +422,15 @@ export class BST<
    * @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 {
-    if (!this.root) return undefined;
-    if (iterationType === IterationType.RECURSIVE) {
+  override getNodeByKey(key: K, iterationType = 'ITERATIVE'): NODE | undefined {
+    if (!this.isRealNode(this.root)) return undefined;
+    if (iterationType === 'RECURSIVE') {
       const _dfs = (cur: NODE): NODE | undefined => {
         if (cur.key === key) return cur;
-        if (!cur.left && !cur.right) return;
+        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
 
-        if (this._compare(cur.key, key) === CP.gt && cur.left) return _dfs(cur.left);
-        if (this._compare(cur.key, key) === CP.lt && cur.right) return _dfs(cur.right);
+        if (this._compare(cur.key, key) === 'GT' && this.isRealNode(cur.left)) return _dfs(cur.left);
+        if (this._compare(cur.key, key) === 'LT' && this.isRealNode(cur.right)) return _dfs(cur.right);
       };
 
       return _dfs(this.root);
@@ -441,10 +438,10 @@ export class BST<
       const queue = new Queue<NODE>([this.root]);
       while (queue.size > 0) {
         const cur = queue.shift();
-        if (cur) {
-          if (this._compare(cur.key, key) === CP.eq) return cur;
-          if (this._compare(cur.key, key) === CP.gt) cur.left && queue.push(cur.left);
-          if (this._compare(cur.key, key) === CP.lt) cur.right && queue.push(cur.right);
+        if (this.isRealNode(cur)) {
+          if (this._compare(cur.key, key) === 'EQ') return cur;
+          if (this._compare(cur.key, key) === 'GT') this.isRealNode(cur.left) && queue.push(cur.left);
+          if (this._compare(cur.key, key) === 'LT') this.isRealNode(cur.right) && queue.push(cur.right);
         }
       }
     }
@@ -489,7 +486,7 @@ export class BST<
     if (!beginRoot) return [];
     const ans: NODE[] = [];
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _traverse = (cur: NODE) => {
         const callbackResult = callback(cur);
         if (callbackResult === identifier) {
@@ -497,23 +494,23 @@ export class BST<
           if (onlyOne) return;
         }
 
-        if (!cur.left && !cur.right) return;
+        if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return;
         // TODO potential bug
         if (callback === this._defaultOneParamCallback) {
-          if (this._compare(cur.key, identifier as K) === CP.gt) cur.left && _traverse(cur.left);
-          if (this._compare(cur.key, identifier as K) === CP.lt) cur.right && _traverse(cur.right);
+          if (this.isRealNode(cur.left) && this._compare(cur.key, identifier as K) === 'GT') _traverse(cur.left);
+          if (this.isRealNode(cur.right) && this._compare(cur.key, identifier as K) === 'LT') _traverse(cur.right);
         } else {
-          cur.left && _traverse(cur.left);
-          cur.right && _traverse(cur.right);
+          this.isRealNode(cur.left) && _traverse(cur.left);
+          this.isRealNode(cur.right) && _traverse(cur.right);
         }
       };
 
       _traverse(beginRoot);
     } else {
-      const queue = new Queue<NODE>([beginRoot]);
-      while (queue.size > 0) {
-        const cur = queue.shift();
-        if (cur) {
+      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);
@@ -521,11 +518,19 @@ export class BST<
           }
           // TODO potential bug
           if (callback === this._defaultOneParamCallback) {
-            if (this._compare(cur.key, identifier as K) === CP.gt) cur.left && queue.push(cur.left);
-            if (this._compare(cur.key, identifier as K) === CP.lt) cur.right && queue.push(cur.right);
+            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 {
-            cur.left && queue.push(cur.left);
-            cur.right && queue.push(cur.right);
+            this.isRealNode(cur.right) && stack.push(cur.right);
+            this.isRealNode(cur.left) && stack.push(cur.left);
           }
         }
       }
@@ -562,7 +567,7 @@ export class BST<
     callback: C = this._defaultOneParamCallback as C,
     pattern: DFSOrderPattern = 'in',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType: IterationType = IterationType.ITERATIVE
+    iterationType: IterationType = 'ITERATIVE'
   ): ReturnType<C>[] {
     return super.dfs(callback, pattern, beginRoot, iterationType, false);
   }
@@ -650,7 +655,7 @@ export class BST<
     let current = this.ensureNode(beginRoot);
     if (!current) return undefined;
 
-    if (this._variant === BSTVariant.STANDARD) {
+    if (this._variant === 'STANDARD') {
       // For BSTVariant.MIN, find the rightmost node
       while (current.right !== undefined) {
         current = current.right;
@@ -692,7 +697,7 @@ export class BST<
    */
   lesserOrGreaterTraverse<C extends BTNCallback<NODE>>(
     callback: C = this._defaultOneParamCallback as C,
-    lesserOrGreater: CP = CP.lt,
+    lesserOrGreater: CP = 'LT',
     targetNode: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
@@ -703,7 +708,7 @@ export class BST<
 
     const targetKey = targetNode.key;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _traverse = (cur: NODE) => {
         const compared = this._compare(cur.key, targetKey);
         if (compared === lesserOrGreater) ans.push(callback(cur));
@@ -752,7 +757,7 @@ export class BST<
     this.clear();
 
     if (sorted.length < 1) return false;
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const buildBalanceBST = (l: number, r: number) => {
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);
@@ -812,7 +817,7 @@ export class BST<
 
     let balanced = true;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _height = (cur: NODE | undefined): number => {
         if (!cur) return 0;
         const leftHeight = _height(cur.left),
@@ -856,7 +861,7 @@ export class BST<
    * @param {NODE | undefined} v - The parameter `v` is of type `NODE | undefined`. This means that it
    * can either be an object of type `NODE` or it can be `undefined`.
    */
-  protected _setRoot(v: NODE | undefined) {
+  protected override _setRoot(v: NODE | undefined) {
     if (v) {
       v.parent = undefined;
     }
@@ -868,14 +873,32 @@ export class BST<
    * 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 CP.gt (greater
-   * than), CP.lt (less than), or CP.eq (equal).
+   * @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 === BSTVariant.STANDARD ? extractedA - extractedB : extractedB - extractedA;
+    const compared = this.variant === 'STANDARD' ? extractedA - extractedB : extractedB - extractedA;
 
-    return compared > 0 ? CP.gt : compared < 0 ? CP.lt : CP.eq;
+    return compared > 0 ? 'GT' : compared < 0 ? 'LT' : 'EQ';
+  }
+
+  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;
+  }
+
+  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;
   }
 }