data-structure-typed 1.50.8 → 1.51.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.50.8",
+  "version": "1.51.0",
   "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",
@@ -34,7 +34,7 @@
     "format:test": "prettier --write 'test/**/*.{js,ts}'",
     "format": "npm run format:src && npm run format:test",
     "check:exist-latest": "sh scripts/check_exist_remotely.sh",
-    "ci": "env && git fetch --tags && npm run inspect && npm run lint && npm run build && npm run test:unit && npm run changelog",
+    "ci": "env && git fetch --tags && npm run update:subs && npm run inspect && npm run lint && npm run build && npm run test:unit && npm run changelog",
     "update:subs": "npm i avl-tree-typed binary-tree-typed bst-typed heap-typed data-structure-typed --save-dev",
     "install:all-subs": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multimap-typed trie-typed undirected-graph-typed queue-typed --save-dev",
     "changelog": "auto-changelog",
@@ -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.50.7",
+    "avl-tree-typed": "^1.50.9",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.50.7",
-    "bst-typed": "^1.50.7",
-    "data-structure-typed": "^1.50.7",
+    "binary-tree-typed": "^1.50.9",
+    "bst-typed": "^1.50.9",
+    "data-structure-typed": "^1.50.9",
     "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.50.7",
+    "heap-typed": "^1.50.9",
     "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

@@ -12,6 +12,7 @@ import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNCallback,
+  IterationType,
   KeyOrNodeOrEntry
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
@@ -85,7 +86,20 @@ export class AVLTreeMultiMap<
     return this._count;
   }
 
-  getMutableCount(): number {
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function calculates the sum of the count property of all nodes in a tree using depth-first
+   * search.
+   * @returns the sum of the count property of all nodes in the tree.
+   */
+  getComputedCount(): number {
     let sum = 0;
     this.dfs(node => (sum += node.count));
     return sum;
@@ -316,8 +330,8 @@ export class AVLTreeMultiMap<
    * values:
    * @returns a boolean value.
    */
-  override perfectlyBalance(iterationType = this.iterationType): boolean {
-    const sorted = this.dfs(node => node, 'in'),
+  override perfectlyBalance(iterationType: IterationType = this.iterationType): boolean {
+    const sorted = this.dfs(node => node, 'IN'),
       n = sorted.length;
     if (sorted.length < 1) return false;
 

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

@@ -264,7 +264,10 @@ export class BinaryTree<
    * @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 = 'ITERATIVE'): NODE | null | undefined {
+  ensureNode(
+    keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
+    iterationType: IterationType = 'ITERATIVE'
+  ): NODE | null | undefined {
     let res: NODE | null | undefined;
     if (this.isRealNode(keyOrNodeOrEntry)) {
       res = keyOrNodeOrEntry;
@@ -594,7 +597,7 @@ export class BinaryTree<
     callback: C = this._defaultOneParamCallback as C,
     onlyOne = false,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE[] {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -684,7 +687,7 @@ export class BinaryTree<
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -711,7 +714,7 @@ 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 = 'ITERATIVE'): NODE | undefined {
+  getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
     if (!this.root) return undefined;
     if (iterationType === 'RECURSIVE') {
       const _dfs = (cur: NODE): NODE | undefined => {
@@ -788,7 +791,7 @@ export class BinaryTree<
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): V | undefined {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -847,7 +850,7 @@ export class BinaryTree<
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): boolean {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -924,7 +927,10 @@ export class BinaryTree<
    * possible values:
    * @returns a boolean value.
    */
-  isBST(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, iterationType = this.iterationType): boolean {
+  isBST(
+    beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
+    iterationType: IterationType = this.iterationType
+  ): boolean {
     // TODO there is a bug
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return true;
@@ -1016,7 +1022,10 @@ export class BinaryTree<
    * values:
    * @returns the height of the binary tree.
    */
-  getHeight(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, iterationType = this.iterationType): number {
+  getHeight(
+    beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
+    iterationType: IterationType = this.iterationType
+  ): number {
     beginRoot = this.ensureNode(beginRoot);
     if (!this.isRealNode(beginRoot)) return -1;
 
@@ -1064,7 +1073,10 @@ export class BinaryTree<
    * to calculate the minimum height of a binary tree. It can have two possible values:
    * @returns The function `getMinHeight` returns the minimum height of a binary tree.
    */
-  getMinHeight(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, iterationType = this.iterationType): number {
+  getMinHeight(
+    beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
+    iterationType: IterationType = this.iterationType
+  ): number {
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return -1;
 
@@ -1164,7 +1176,7 @@ export class BinaryTree<
    */
   getLeftMost(
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
     if (this.isNIL(beginRoot)) return beginRoot as NODE;
     beginRoot = this.ensureNode(beginRoot);
@@ -1211,7 +1223,7 @@ export class BinaryTree<
    */
   getRightMost(
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
     if (this.isNIL(beginRoot)) return beginRoot as NODE;
     // TODO support get right most by passing key in
@@ -1340,7 +1352,7 @@ export class BinaryTree<
    */
   dfs<C extends BTNCallback<NODE | null | undefined>>(
     callback: C = this._defaultOneParamCallback as C,
-    pattern: DFSOrderPattern = 'in',
+    pattern: DFSOrderPattern = 'IN',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = 'ITERATIVE',
     includeNull = false
@@ -1351,7 +1363,7 @@ export class BinaryTree<
     if (iterationType === 'RECURSIVE') {
       const _traverse = (node: NODE | null | undefined) => {
         switch (pattern) {
-          case 'in':
+          case 'IN':
             if (includeNull) {
               if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
               this.isNodeOrNull(node) && ans.push(callback(node));
@@ -1362,7 +1374,7 @@ export class BinaryTree<
               if (this.isRealNode(node) && this.isRealNode(node.right)) _traverse(node.right);
             }
             break;
-          case 'pre':
+          case 'PRE':
             if (includeNull) {
               this.isNodeOrNull(node) && ans.push(callback(node));
               if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
@@ -1373,7 +1385,7 @@ export class BinaryTree<
               if (this.isRealNode(node) && this.isRealNode(node.right)) _traverse(node.right);
             }
             break;
-          case 'post':
+          case 'POST':
             if (includeNull) {
               if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
               if (this.isRealNode(node) && this.isNodeOrNull(node.right)) _traverse(node.right);
@@ -1405,17 +1417,17 @@ export class BinaryTree<
           ans.push(callback(cur.node));
         } else {
           switch (pattern) {
-            case 'in':
+            case 'IN':
               cur.node && stack.push({ opt: 0, node: cur.node.right });
               stack.push({ opt: 1, node: cur.node });
               cur.node && stack.push({ opt: 0, node: cur.node.left });
               break;
-            case 'pre':
+            case 'PRE':
               cur.node && stack.push({ opt: 0, node: cur.node.right });
               cur.node && stack.push({ opt: 0, node: cur.node.left });
               stack.push({ opt: 1, node: cur.node });
               break;
-            case 'post':
+            case 'POST':
               stack.push({ opt: 1, node: cur.node });
               cur.node && stack.push({ opt: 0, node: cur.node.right });
               cur.node && stack.push({ opt: 0, node: cur.node.left });
@@ -1476,7 +1488,7 @@ export class BinaryTree<
   bfs<C extends BTNCallback<NODE | null>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType,
+    iterationType: IterationType = this.iterationType,
     includeNull = false
   ): ReturnType<C>[] {
     beginRoot = this.ensureNode(beginRoot);
@@ -1570,7 +1582,7 @@ export class BinaryTree<
   listLevels<C extends BTNCallback<NODE | null>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType,
+    iterationType: IterationType = this.iterationType,
     includeNull = false
   ): ReturnType<C>[][] {
     beginRoot = this.ensureNode(beginRoot);
@@ -1640,7 +1652,7 @@ export class BinaryTree<
    */
   morris<C extends BTNCallback<NODE>>(
     callback: C = this._defaultOneParamCallback as C,
-    pattern: DFSOrderPattern = 'in',
+    pattern: DFSOrderPattern = 'IN',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root
   ): ReturnType<C>[] {
     beginRoot = this.ensureNode(beginRoot);
@@ -1669,7 +1681,7 @@ export class BinaryTree<
       _reverseEdge(tail);
     };
     switch (pattern) {
-      case 'in':
+      case 'IN':
         while (cur) {
           if (cur.left) {
             const predecessor = this.getPredecessor(cur);
@@ -1685,7 +1697,7 @@ export class BinaryTree<
           cur = cur.right;
         }
         break;
-      case 'pre':
+      case 'PRE':
         while (cur) {
           if (cur.left) {
             const predecessor = this.getPredecessor(cur);
@@ -1703,7 +1715,7 @@ export class BinaryTree<
           cur = cur.right;
         }
         break;
-      case 'post':
+      case 'POST':
         while (cur) {
           if (cur.left) {
             const predecessor = this.getPredecessor(cur);

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

@@ -210,7 +210,10 @@ export class BST<
    * 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 = 'ITERATIVE'): NODE | undefined {
+  override ensureNode(
+    keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
+    iterationType: IterationType = 'ITERATIVE'
+  ): NODE | undefined {
     let res: NODE | undefined;
     if (this.isRealNode(keyOrNodeOrEntry)) {
       res = keyOrNodeOrEntry;
@@ -321,7 +324,7 @@ export class BST<
     keysOrNodesOrEntries: Iterable<KeyOrNodeOrEntry<K, V, NODE>>,
     values?: Iterable<V | undefined>,
     isBalanceAdd = true,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): boolean[] {
     const inserted: boolean[] = [];
 
@@ -422,7 +425,8 @@ 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 = 'ITERATIVE'): NODE | undefined {
+  override getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
+    // return this.getNodes(key, this._defaultOneParamCallback, true, this.root, iterationType)[0];
     if (!this.isRealNode(this.root)) return undefined;
     if (iterationType === 'RECURSIVE') {
       const _dfs = (cur: NODE): NODE | undefined => {
@@ -480,7 +484,7 @@ export class BST<
     callback: C = this._defaultOneParamCallback as C,
     onlyOne = false,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE[] {
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return [];
@@ -565,7 +569,7 @@ export class BST<
    */
   override dfs<C extends BTNCallback<NODE>>(
     callback: C = this._defaultOneParamCallback as C,
-    pattern: DFSOrderPattern = 'in',
+    pattern: DFSOrderPattern = 'IN',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
     iterationType: IterationType = 'ITERATIVE'
   ): ReturnType<C>[] {
@@ -597,7 +601,7 @@ export class BST<
   override bfs<C extends BTNCallback<NODE>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
     return super.bfs(callback, beginRoot, iterationType, false);
   }
@@ -628,7 +632,7 @@ export class BST<
   override listLevels<C extends BTNCallback<NODE>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): ReturnType<C>[][] {
     return super.listLevels(callback, beginRoot, iterationType, false);
   }
@@ -699,7 +703,7 @@ export class BST<
     callback: C = this._defaultOneParamCallback as C,
     lesserOrGreater: CP = 'LT',
     targetNode: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): ReturnType<C>[] {
     targetNode = this.ensureNode(targetNode);
     const ans: ReturnType<BTNCallback<NODE>>[] = [];
@@ -751,8 +755,8 @@ export class BST<
    * values:
    * @returns The function `perfectlyBalance` returns a boolean value.
    */
-  perfectlyBalance(iterationType = this.iterationType): boolean {
-    const sorted = this.dfs(node => node, 'in'),
+  perfectlyBalance(iterationType: IterationType = this.iterationType): boolean {
+    const sorted = this.dfs(node => node, 'IN'),
       n = sorted.length;
     this.clear();
 
@@ -812,7 +816,7 @@ export class BST<
    * to check if the AVL tree is balanced. It can have two possible values:
    * @returns a boolean value.
    */
-  isAVLBalanced(iterationType = this.iterationType): boolean {
+  isAVLBalanced(iterationType: IterationType = this.iterationType): boolean {
     if (!this.root) return true;
 
     let balanced = true;
@@ -884,6 +888,15 @@ export class BST<
     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);
@@ -893,6 +906,14 @@ export class BST<
     // 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);

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

@@ -2,6 +2,7 @@ import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNCallback,
+  IterationType,
   KeyOrNodeOrEntry,
   RBTreeOptions,
   RedBlackTreeNested,
@@ -25,9 +26,9 @@ export class RedBlackTreeNode<
    * associated with the key in the Red-Black Tree Node. It is not required and can be omitted when
    * creating a new instance of the Red-Black Tree Node.
    * @param {RBTNColor} color - The `color` parameter is used to specify the color of the Red-Black
-   * Tree Node. It is an optional parameter with a default value of `RBTNColor.BLACK`.
+   * Tree Node. It is an optional parameter with a default value of `'BLACK'`.
    */
-  constructor(key: K, value?: V, color: RBTNColor = RBTNColor.BLACK) {
+  constructor(key: K, value?: V, color: RBTNColor = 'BLACK') {
     super(key, value);
     this._color = color;
   }
@@ -106,12 +107,12 @@ export class RedBlackTree<
    * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
    * associated with the key in the node. It is not required and can be omitted if not needed.
    * @param {RBTNColor} color - The "color" parameter is used to specify the color of the node in a
-   * Red-Black Tree. It is an optional parameter with a default value of "RBTNColor.BLACK". The color
-   * can be either "RBTNColor.RED" or "RBTNColor.BLACK".
+   * Red-Black Tree. It is an optional parameter with a default value of "'BLACK'". The color
+   * can be either "'RED'" or "'BLACK'".
    * @returns The method is returning a new instance of a RedBlackTreeNode with the specified key,
    * value, and color.
    */
-  override createNode(key: K, value?: V, color: RBTNColor = RBTNColor.BLACK): NODE {
+  override createNode(key: K, value?: V, color: RBTNColor = 'BLACK'): NODE {
     return new RedBlackTreeNode<K, V, NODE>(key, value, color) as NODE;
   }
 
@@ -156,10 +157,10 @@ export class RedBlackTree<
       if (key === undefined || key === null) {
         return;
       } else {
-        node = this.createNode(key, value, RBTNColor.RED);
+        node = this.createNode(key, value, 'RED');
       }
     } else if (!this.isNode(keyOrNodeOrEntry)) {
-      node = this.createNode(keyOrNodeOrEntry, value, RBTNColor.RED);
+      node = this.createNode(keyOrNodeOrEntry, value, 'RED');
     } else {
       return;
     }
@@ -232,9 +233,8 @@ export class RedBlackTree<
     identifier: ReturnType<C> | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: BSTNKeyOrNode<K, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
-    // if ((identifier as any) instanceof RedBlackTreeNode) callback = (node => node) as C;
     return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
   }
 
@@ -282,7 +282,7 @@ export class RedBlackTree<
     if (insertStatus === 'CREATED') {
       // Ensure the root is black
       if (this.isRealNode(this._root)) {
-        this._root.color = RBTNColor.BLACK;
+        this._root.color = 'BLACK';
       } else {
         return false;
       }
@@ -363,7 +363,7 @@ export class RedBlackTree<
     this._size--;
 
     // If the original color was black, fix the tree
-    if (originalColor === RBTNColor.BLACK) {
+    if (originalColor === 'BLACK') {
       this._deleteFixup(replacementNode);
     }
 
@@ -451,7 +451,7 @@ export class RedBlackTree<
 
     node.left = this.SENTINEL;
     node.right = this.SENTINEL;
-    node.color = RBTNColor.RED;
+    node.color = 'RED';
 
     this._insertFixup(node);
     return 'CREATED';
@@ -500,16 +500,16 @@ export class RedBlackTree<
    */
   protected _insertFixup(z: NODE | undefined): void {
     // Continue fixing the tree as long as the parent of z is red
-    while (z?.parent?.color === RBTNColor.RED) {
+    while (z?.parent?.color === 'RED') {
       // Check if the parent of z is the left child of its parent
       if (z.parent === z.parent.parent?.left) {
         // Case 1: The uncle (y) of z is red
         const y = z.parent.parent.right;
-        if (y?.color === RBTNColor.RED) {
+        if (y?.color === 'RED') {
           // Set colors to restore properties of Red-Black Tree
-          z.parent.color = RBTNColor.BLACK;
-          y.color = RBTNColor.BLACK;
-          z.parent.parent.color = RBTNColor.RED;
+          z.parent.color = 'BLACK';
+          y.color = 'BLACK';
+          z.parent.parent.color = 'RED';
           // Move up the tree to continue fixing
           z = z.parent.parent;
         } else {
@@ -523,8 +523,8 @@ export class RedBlackTree<
           // Case 3: The uncle (y) of z is black, and z is a left child
           // Adjust colors and perform a right rotation
           if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
-            z.parent.color = RBTNColor.BLACK;
-            z.parent.parent.color = RBTNColor.RED;
+            z.parent.color = 'BLACK';
+            z.parent.parent.color = 'RED';
             this._rightRotate(z.parent.parent);
           }
         }
@@ -532,10 +532,10 @@ export class RedBlackTree<
         // Symmetric case for the right child (left and right exchanged)
         // Follow the same logic as above with left and right exchanged
         const y: NODE | undefined = z?.parent?.parent?.left;
-        if (y?.color === RBTNColor.RED) {
-          z.parent.color = RBTNColor.BLACK;
-          y.color = RBTNColor.BLACK;
-          z.parent.parent!.color = RBTNColor.RED;
+        if (y?.color === 'RED') {
+          z.parent.color = 'BLACK';
+          y.color = 'BLACK';
+          z.parent.parent!.color = 'RED';
           z = z.parent.parent;
         } else {
           if (z === z.parent.left) {
@@ -544,8 +544,8 @@ export class RedBlackTree<
           }
 
           if (z && this.isRealNode(z.parent) && this.isRealNode(z.parent.parent)) {
-            z.parent.color = RBTNColor.BLACK;
-            z.parent.parent.color = RBTNColor.RED;
+            z.parent.color = 'BLACK';
+            z.parent.parent.color = 'RED';
             this._leftRotate(z.parent.parent);
           }
         }
@@ -553,7 +553,7 @@ export class RedBlackTree<
     }
 
     // Ensure that the root is black after fixing
-    if (this.isRealNode(this._root)) this._root.color = RBTNColor.BLACK;
+    if (this.isRealNode(this._root)) this._root.color = 'BLACK';
   }
 
   /**
@@ -573,14 +573,14 @@ export class RedBlackTree<
    */
   protected _deleteFixup(node: NODE | undefined): void {
     // Early exit condition
-    if (!node || node === this.root || node.color === RBTNColor.BLACK) {
+    if (!node || node === this.root || node.color === 'BLACK') {
       if (node) {
-        node.color = RBTNColor.BLACK; // Ensure the final node is black
+        node.color = 'BLACK'; // Ensure the final node is black
       }
       return;
     }
 
-    while (node && node !== this.root && node.color === RBTNColor.BLACK) {
+    while (node && node !== this.root && node.color === 'BLACK') {
       const parent: NODE | undefined = node.parent;
 
       if (!parent) {
@@ -591,22 +591,22 @@ export class RedBlackTree<
         let sibling = parent.right;
 
         // Cases 1 and 2: Sibling is red or both children of sibling are black
-        if (sibling?.color === RBTNColor.RED) {
-          sibling.color = RBTNColor.BLACK;
-          parent.color = RBTNColor.RED;
+        if (sibling?.color === 'RED') {
+          sibling.color = 'BLACK';
+          parent.color = 'RED';
           this._leftRotate(parent);
           sibling = parent.right;
         }
 
         // Case 3: Sibling's left child is black
-        if ((sibling?.left?.color ?? RBTNColor.BLACK) === RBTNColor.BLACK) {
-          if (sibling) sibling.color = RBTNColor.RED;
+        if ((sibling?.left?.color ?? 'BLACK') === 'BLACK') {
+          if (sibling) sibling.color = 'RED';
           node = parent;
         } else {
           // Case 4: Adjust colors and perform a right rotation
-          if (sibling?.left) sibling.left.color = RBTNColor.BLACK;
+          if (sibling?.left) sibling.left.color = 'BLACK';
           if (sibling) sibling.color = parent.color;
-          parent.color = RBTNColor.BLACK;
+          parent.color = 'BLACK';
           this._rightRotate(parent);
           node = this.root;
         }
@@ -615,22 +615,22 @@ export class RedBlackTree<
         let sibling = parent.left;
 
         // Cases 1 and 2: Sibling is red or both children of sibling are black
-        if (sibling?.color === RBTNColor.RED) {
-          sibling.color = RBTNColor.BLACK;
-          if (parent) parent.color = RBTNColor.RED;
+        if (sibling?.color === 'RED') {
+          sibling.color = 'BLACK';
+          if (parent) parent.color = 'RED';
           this._rightRotate(parent);
           if (parent) sibling = parent.left;
         }
 
         // Case 3: Sibling's left child is black
-        if ((sibling?.right?.color ?? RBTNColor.BLACK) === RBTNColor.BLACK) {
-          if (sibling) sibling.color = RBTNColor.RED;
+        if ((sibling?.right?.color ?? 'BLACK') === 'BLACK') {
+          if (sibling) sibling.color = 'RED';
           node = parent;
         } else {
           // Case 4: Adjust colors and perform a left rotation
-          if (sibling?.right) sibling.right.color = RBTNColor.BLACK;
+          if (sibling?.right) sibling.right.color = 'BLACK';
           if (sibling) sibling.color = parent.color;
-          if (parent) parent.color = RBTNColor.BLACK;
+          if (parent) parent.color = 'BLACK';
           this._leftRotate(parent);
           node = this.root;
         }
@@ -639,7 +639,7 @@ export class RedBlackTree<
 
     // Ensure that the final node (possibly the root) is black
     if (node) {
-      node.color = RBTNColor.BLACK;
+      node.color = 'BLACK';
     }
   }