data-structure-typed 1.50.7 → 1.50.9

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

@@ -1,4 +1,3 @@
-import { BSTVariant, CP, IterationType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { Queue } from '../queue';
 export class BSTNode extends BinaryTreeNode {
@@ -86,7 +85,7 @@ export class BST extends BinaryTree {
     get root() {
         return this._root;
     }
-    _variant = BSTVariant.STANDARD;
+    _variant = 'STANDARD';
     /**
      * The function returns the value of the _variant property.
      * @returns The value of the `_variant` property.
@@ -166,10 +165,10 @@ export class BST extends BinaryTree {
      * @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.
      */
-    ensureNode(keyOrNodeOrEntry, iterationType = IterationType.ITERATIVE) {
+    ensureNode(keyOrNodeOrEntry, iterationType = 'ITERATIVE') {
         let res;
         if (this.isRealNode(keyOrNodeOrEntry)) {
             res = keyOrNodeOrEntry;
@@ -219,7 +218,7 @@ export class BST extends BinaryTree {
         }
         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);
@@ -230,7 +229,7 @@ export class BST extends BinaryTree {
                 //   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++;
@@ -339,7 +338,7 @@ export class BST extends BinaryTree {
                 }
             }
         };
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             _dfs(sorted);
         }
         else {
@@ -365,18 +364,19 @@ export class BST extends 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, iterationType = IterationType.ITERATIVE) {
+    getNodeByKey(key, iterationType = 'ITERATIVE') {
+        // return this.getNodes(key, this._defaultOneParamCallback, true, this.root, iterationType)[0];
         if (!this.isRealNode(this.root))
             return undefined;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _dfs = (cur) => {
                 if (cur.key === key)
                     return cur;
                 if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
-                if (this._compare(cur.key, key) === CP.gt && this.isRealNode(cur.left))
+                if (this._compare(cur.key, key) === 'GT' && this.isRealNode(cur.left))
                     return _dfs(cur.left);
-                if (this._compare(cur.key, key) === CP.lt && this.isRealNode(cur.right))
+                if (this._compare(cur.key, key) === 'LT' && this.isRealNode(cur.right))
                     return _dfs(cur.right);
             };
             return _dfs(this.root);
@@ -386,11 +386,11 @@ export class BST extends BinaryTree {
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (this.isRealNode(cur)) {
-                    if (this._compare(cur.key, key) === CP.eq)
+                    if (this._compare(cur.key, key) === 'EQ')
                         return cur;
-                    if (this._compare(cur.key, key) === CP.gt)
+                    if (this._compare(cur.key, key) === 'GT')
                         this.isRealNode(cur.left) && queue.push(cur.left);
-                    if (this._compare(cur.key, key) === CP.lt)
+                    if (this._compare(cur.key, key) === 'LT')
                         this.isRealNode(cur.right) && queue.push(cur.right);
                 }
             }
@@ -429,7 +429,7 @@ export class BST extends BinaryTree {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _traverse = (cur) => {
                 const callbackResult = callback(cur);
                 if (callbackResult === identifier) {
@@ -441,10 +441,10 @@ export class BST extends BinaryTree {
                     return;
                 // TODO potential bug
                 if (callback === this._defaultOneParamCallback) {
-                    if (this._compare(cur.key, identifier) === CP.gt)
-                        this.isRealNode(cur.left) && _traverse(cur.left);
-                    if (this._compare(cur.key, identifier) === CP.lt)
-                        this.isRealNode(cur.right) && _traverse(cur.right);
+                    if (this.isRealNode(cur.left) && this._compare(cur.key, identifier) === 'GT')
+                        _traverse(cur.left);
+                    if (this.isRealNode(cur.right) && this._compare(cur.key, identifier) === 'LT')
+                        _traverse(cur.right);
                 }
                 else {
                     this.isRealNode(cur.left) && _traverse(cur.left);
@@ -454,9 +454,9 @@ export class BST extends BinaryTree {
             _traverse(beginRoot);
         }
         else {
-            const queue = new Queue([beginRoot]);
-            while (queue.size > 0) {
-                const cur = queue.shift();
+            const stack = [beginRoot];
+            while (stack.length > 0) {
+                const cur = stack.pop();
                 if (this.isRealNode(cur)) {
                     const callbackResult = callback(cur);
                     if (callbackResult === identifier) {
@@ -466,14 +466,20 @@ export class BST extends BinaryTree {
                     }
                     // TODO potential bug
                     if (callback === this._defaultOneParamCallback) {
-                        if (this._compare(cur.key, identifier) === CP.gt)
-                            this.isRealNode(cur.left) && queue.push(cur.left);
-                        if (this._compare(cur.key, identifier) === CP.lt)
-                            this.isRealNode(cur.right) && queue.push(cur.right);
+                        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.left) && queue.push(cur.left);
-                        this.isRealNode(cur.right) && queue.push(cur.right);
+                        this.isRealNode(cur.right) && stack.push(cur.right);
+                        this.isRealNode(cur.left) && stack.push(cur.left);
                     }
                 }
             }
@@ -503,7 +509,7 @@ export class BST extends BinaryTree {
      * following values:
      * @returns The method is returning an array of the return type of the callback function.
      */
-    dfs(callback = this._defaultOneParamCallback, pattern = 'in', beginRoot = this.root, iterationType = IterationType.ITERATIVE) {
+    dfs(callback = this._defaultOneParamCallback, pattern = 'IN', beginRoot = this.root, iterationType = 'ITERATIVE') {
         return super.dfs(callback, pattern, beginRoot, iterationType, false);
     }
     /**
@@ -576,7 +582,7 @@ export class BST extends BinaryTree {
         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;
@@ -615,7 +621,7 @@ export class BST extends 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._defaultOneParamCallback, lesserOrGreater = CP.lt, targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = 'LT', targetNode = this.root, iterationType = this.iterationType) {
         targetNode = this.ensureNode(targetNode);
         const ans = [];
         if (!targetNode)
@@ -623,7 +629,7 @@ export class BST extends BinaryTree {
         if (!this.root)
             return ans;
         const targetKey = targetNode.key;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _traverse = (cur) => {
                 const compared = this._compare(cur.key, targetKey);
                 if (compared === lesserOrGreater)
@@ -669,11 +675,11 @@ export class BST extends BinaryTree {
      * @returns The function `perfectlyBalance` returns a boolean value.
      */
     perfectlyBalance(iterationType = this.iterationType) {
-        const sorted = this.dfs(node => node, 'in'), n = sorted.length;
+        const sorted = this.dfs(node => node, 'IN'), n = sorted.length;
         this.clear();
         if (sorted.length < 1)
             return false;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -730,7 +736,7 @@ export class BST extends BinaryTree {
         if (!this.root)
             return true;
         let balanced = true;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _height = (cur) => {
                 if (!cur)
                     return 0;
@@ -787,13 +793,46 @@ export class BST extends BinaryTree {
      * 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).
      */
     _compare(a, b) {
         const extractedA = this.extractor(a);
         const extractedB = this.extractor(b);
-        const compared = this.variant === BSTVariant.STANDARD ? extractedA - extractedB : extractedB - extractedA;
-        return compared > 0 ? CP.gt : compared < 0 ? CP.lt : CP.eq;
+        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;
     }
 }

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

@@ -1,4 +1,4 @@
-import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
 import { CRUD, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
@@ -12,7 +12,7 @@ export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTre
      * 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);
     protected _color: RBTNColor;
@@ -58,8 +58,8 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * @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.
      */
@@ -140,7 +140,7 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * its default value is taken from the `iterationType` property of the class.
      * @returns The method is returning a value of type `NODE | null | undefined`.
      */
-    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, beginRoot?: BSTNKeyOrNode<K, NODE>, iterationType?: import("../../types").IterationType): NODE | null | undefined;
+    getNode<C extends BTNCallback<NODE>>(identifier: ReturnType<C> | undefined, callback?: C, beginRoot?: BSTNKeyOrNode<K, NODE>, iterationType?: IterationType): NODE | null | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -1,4 +1,3 @@
-import { CRUD, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 export class RedBlackTreeNode extends BSTNode {
     /**
@@ -10,9 +9,9 @@ export class RedBlackTreeNode extends BSTNode {
      * 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, value, color = RBTNColor.BLACK) {
+    constructor(key, value, color = 'BLACK') {
         super(key, value);
         this._color = color;
     }
@@ -73,12 +72,12 @@ export class RedBlackTree extends BST {
      * @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.
      */
-    createNode(key, value, color = RBTNColor.BLACK) {
+    createNode(key, value, color = 'BLACK') {
         return new RedBlackTreeNode(key, value, color);
     }
     /**
@@ -122,11 +121,11 @@ export class RedBlackTree extends BST {
                 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;
@@ -193,9 +192,7 @@ export class RedBlackTree extends BST {
      * @returns The method is returning a value of type `NODE | null | undefined`.
      */
     getNode(identifier, callback = this._defaultOneParamCallback, beginRoot = this.root, iterationType = this.iterationType) {
-        if (identifier instanceof RedBlackTreeNode)
-            callback = (node => node);
-        return super.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
+        return this.getNodes(identifier, callback, true, beginRoot, iterationType)[0] ?? undefined;
     }
     /**
      * Time Complexity: O(1)
@@ -234,10 +231,10 @@ export class RedBlackTree extends BST {
         if (!this.isRealNode(newNode))
             return false;
         const insertStatus = this._insert(newNode);
-        if (insertStatus === CRUD.CREATED) {
+        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;
@@ -246,7 +243,7 @@ export class RedBlackTree extends BST {
             return true;
         }
         else
-            return insertStatus === CRUD.UPDATED;
+            return insertStatus === 'UPDATED';
     }
     /**
      * Time Complexity: O(log n)
@@ -313,7 +310,7 @@ export class RedBlackTree extends BST {
         }
         this._size--;
         // If the original color was black, fix the tree
-        if (originalColor === RBTNColor.BLACK) {
+        if (originalColor === 'BLACK') {
             this._deleteFixup(replacementNode);
         }
         results.push({ deleted: nodeToDelete, needBalanced: undefined });
@@ -378,7 +375,7 @@ export class RedBlackTree extends BST {
             }
             else {
                 this._replaceNode(current, node);
-                return CRUD.UPDATED;
+                return 'UPDATED';
             }
         }
         node.parent = parent;
@@ -393,9 +390,9 @@ export class RedBlackTree extends BST {
         }
         node.left = this.SENTINEL;
         node.right = this.SENTINEL;
-        node.color = RBTNColor.RED;
+        node.color = 'RED';
         this._insertFixup(node);
-        return CRUD.CREATED;
+        return 'CREATED';
     }
     /**
      * Time Complexity: O(1)
@@ -438,16 +435,16 @@ export class RedBlackTree extends BST {
      */
     _insertFixup(z) {
         // 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;
                 }
@@ -461,8 +458,8 @@ export class RedBlackTree extends BST {
                     // 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);
                     }
                 }
@@ -471,10 +468,10 @@ export class RedBlackTree extends BST {
                 // Symmetric case for the right child (left and right exchanged)
                 // Follow the same logic as above with left and right exchanged
                 const y = 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 {
@@ -483,8 +480,8 @@ export class RedBlackTree extends BST {
                         this._rightRotate(z);
                     }
                     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);
                     }
                 }
@@ -492,7 +489,7 @@ export class RedBlackTree extends BST {
         }
         // Ensure that the root is black after fixing
         if (this.isRealNode(this._root))
-            this._root.color = RBTNColor.BLACK;
+            this._root.color = 'BLACK';
     }
     /**
      * Time Complexity: O(log n)
@@ -510,13 +507,13 @@ export class RedBlackTree extends BST {
      */
     _deleteFixup(node) {
         // 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.parent;
             if (!parent) {
                 break; // Ensure the loop terminates if there's an issue with the tree structure
@@ -524,25 +521,25 @@ export class RedBlackTree extends BST {
             if (node === parent.left) {
                 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?.left?.color ?? 'BLACK') === 'BLACK') {
                     if (sibling)
-                        sibling.color = RBTNColor.RED;
+                        sibling.color = 'RED';
                     node = parent;
                 }
                 else {
                     // Case 4: Adjust colors and perform a right rotation
                     if (sibling?.left)
-                        sibling.left.color = RBTNColor.BLACK;
+                        sibling.left.color = 'BLACK';
                     if (sibling)
                         sibling.color = parent.color;
-                    parent.color = RBTNColor.BLACK;
+                    parent.color = 'BLACK';
                     this._rightRotate(parent);
                     node = this.root;
                 }
@@ -551,28 +548,28 @@ export class RedBlackTree extends BST {
                 // Symmetric case for the right child (left and right exchanged)
                 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 (sibling?.color === 'RED') {
+                    sibling.color = 'BLACK';
                     if (parent)
-                        parent.color = RBTNColor.RED;
+                        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?.right?.color ?? 'BLACK') === 'BLACK') {
                     if (sibling)
-                        sibling.color = RBTNColor.RED;
+                        sibling.color = 'RED';
                     node = parent;
                 }
                 else {
                     // Case 4: Adjust colors and perform a left rotation
                     if (sibling?.right)
-                        sibling.right.color = RBTNColor.BLACK;
+                        sibling.right.color = 'BLACK';
                     if (sibling)
                         sibling.color = parent.color;
                     if (parent)
-                        parent.color = RBTNColor.BLACK;
+                        parent.color = 'BLACK';
                     this._leftRotate(parent);
                     node = this.root;
                 }
@@ -580,7 +577,7 @@ export class RedBlackTree extends BST {
         }
         // Ensure that the final node (possibly the root) is black
         if (node) {
-            node.color = RBTNColor.BLACK;
+            node.color = 'BLACK';
         }
     }
     /**

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

@@ -5,22 +5,24 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
-import { IterationType } from '../../types';
+import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry, TreeMultiMapNested, TreeMultiMapNodeNested, TreeMultiMapOptions } from '../../types';
+import { RBTNColor } 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> {
     /**
-     * The constructor function initializes an instance of a class with a key, value, and count.
-     * @param {K} key - The key parameter is of type K, which represents the type of the key for the
-     * constructor. It is required and must be provided when creating an instance of the class.
-     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
-     * value associated with the key in the constructor. If no value is provided, it will be `undefined`.
-     * @param [count=1] - The "count" parameter is an optional parameter that specifies the number of
-     * times the key-value pair should be repeated. If no value is provided for "count", it defaults to
-     * 1.
-     */
-    constructor(key: K, value?: V, count?: number);
+     * 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
+     * used to identify and locate the node within the tree.
+     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
+     * associated with the key in the Red-Black Tree node. It is not required and can be omitted when
+     * creating a new node.
+     * @param [count=1] - The `count` parameter represents the number of occurrences of a particular key
+     * in the Red-Black Tree. It is an optional parameter with a default value of 1.
+     * @param {RBTNColor} [color=BLACK] - The `color` parameter is used to specify the color of the node
+     * in a Red-Black Tree. It is optional and has a default value of `'BLACK'`.
+     */
+    constructor(key: K, value?: V, count?: number, color?: RBTNColor);
     protected _count: number;
     /**
      * The function returns the value of the private variable _count.
@@ -51,19 +53,34 @@ export declare class TreeMultiMap<K = any, V = any, NODE extends TreeMultiMapNod
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count(): number;
-    getMutableCount(): number;
     /**
-     * The function creates a new TreeMultiMapNode object with the specified key, value, and count.
-     * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
-     * which is a generic type that can be replaced with any specific type when using the function.
-     * @param {V} [value] - The `value` parameter is an optional parameter that represents the value
-     * associated with the key in the node. It is of type `V`, which can be any data type.
-     * @param {number} [count] - The `count` parameter represents the number of occurrences of a
-     * key-value pair in the TreeMultiMap. It is an optional parameter, so if it is not provided, it will
-     * default to 1.
-     * @returns a new instance of the TreeMultiMapNode class, casted as NODE.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
-    createNode(key: K, value?: V, count?: number): NODE;
+    /**
+     * 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;
+    /**
+     * The function creates a new TreeMultiMapNode with the specified key, value, color, and count.
+     * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
+     * which is a generic type representing the key type of the node.
+     * @param {V} [value] - The `value` parameter represents the value associated with the key in the
+     * node. It is an optional parameter, which means it can be omitted when calling the `createNode`
+     * function. If provided, it should be of type `V`.
+     * @param {RBTNColor} [color=BLACK] - The color parameter is used to specify the color of the node in
+     * a Red-Black Tree. It can have two possible values: 'RED' or 'BLACK'. The default value is 'BLACK'.
+     * @param {number} [count] - The `count` parameter represents the number of occurrences of a key in
+     * the tree. It is an optional parameter and is used to keep track of the number of values associated
+     * with a key in the tree.
+     * @returns A new instance of the TreeMultiMapNode class is being returned.
+     */
+    createNode(key: K, value?: V, color?: RBTNColor, count?: number): NODE;
     /**
      * The function creates a new instance of a TreeMultiMap with the specified options and returns it.
      * @param [options] - The `options` parameter is an optional object that contains additional