directed-graph-typed 1.50.6 → 1.50.8

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

@@ -6,7 +6,6 @@
  * @license MIT License
  */
 import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry } from '../../types';
-import { IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class AVLTreeMultiMapNode<K = any, V = any, NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNodeNested<K, V>> extends AVLTreeNode<K, V, NODE> {
@@ -46,6 +45,7 @@ export declare class AVLTreeMultiMap<K = any, V = any, NODE extends AVLTreeMulti
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count(): number;
+    getMutableCount(): number;
     /**
      * The function creates a new BSTNode with the given key, value, and count.
      * @param {K} key - The key parameter is the unique identifier for the binary tree node. It is used to
@@ -156,7 +156,7 @@ export declare class AVLTreeMultiMap<K = any, V = any, NODE extends AVLTreeMulti
      * values:
      * @returns a boolean value.
      */
-    perfectlyBalance(iterationType?: IterationType): boolean;
+    perfectlyBalance(iterationType?: import("../../types").IterationType): boolean;
     /**
      * Time complexity: O(n)
      * Space complexity: O(n)

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AVLTreeMultiMap = exports.AVLTreeMultiMapNode = void 0;
-const types_1 = require("../../types");
 const avl_tree_1 = require("./avl-tree");
 class AVLTreeMultiMapNode extends avl_tree_1.AVLTreeNode {
     /**
@@ -53,6 +52,9 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * @returns the sum of the count property of all nodes in the tree.
      */
     get count() {
+        return this._count;
+    }
+    getMutableCount() {
         let sum = 0;
         this.dfs(node => (sum += node.count));
         return sum;
@@ -202,10 +204,10 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
                 }
                 else {
                     const { familyPosition: fp } = curr;
-                    if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
+                    if (fp === 'LEFT' || fp === 'ROOT_LEFT') {
                         parent.left = curr.right;
                     }
-                    else if (fp === types_1.FamilyPosition.RIGHT || fp === types_1.FamilyPosition.ROOT_RIGHT) {
+                    else if (fp === 'RIGHT' || fp === 'ROOT_RIGHT') {
                         parent.right = curr.right;
                     }
                     needBalanced = parent;
@@ -272,7 +274,7 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
         if (sorted.length < 1)
             return false;
         this.clear();
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;

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

@@ -135,11 +135,11 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * `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): NODE | null | undefined;
+    ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: string): NODE | null | undefined;
     /**
      * The function "isNode" checks if an keyOrNodeOrEntry is an instance of the BinaryTreeNode class.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V,NODE>`.
@@ -248,7 +248,7 @@ export declare class BinaryTree<K = any, V = any, NODE extends BinaryTreeNode<K,
      * @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): NODE | undefined;
+    getNodeByKey(key: K, iterationType?: string): NODE | undefined;
     get<C extends BTNCallback<NODE, K>>(identifier: K, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
     get<C extends BTNCallback<NODE, NODE>>(identifier: NODE | null | undefined, callback?: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;
     get<C extends BTNCallback<NODE>>(identifier: ReturnType<C>, callback: C, beginRoot?: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): V | undefined;

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

@@ -8,7 +8,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinaryTree = exports.BinaryTreeNode = void 0;
-const types_1 = require("../../types");
 const utils_1 = require("../../utils");
 const queue_1 = require("../queue");
 const base_1 = require("../base");
@@ -75,15 +74,15 @@ class BinaryTreeNode {
     get familyPosition() {
         const that = this;
         if (!this.parent) {
-            return this.left || this.right ? types_1.FamilyPosition.ROOT : types_1.FamilyPosition.ISOLATED;
+            return this.left || this.right ? 'ROOT' : 'ISOLATED';
         }
         if (this.parent.left === that) {
-            return this.left || this.right ? types_1.FamilyPosition.ROOT_LEFT : types_1.FamilyPosition.LEFT;
+            return this.left || this.right ? 'ROOT_LEFT' : 'LEFT';
         }
         else if (this.parent.right === that) {
-            return this.left || this.right ? types_1.FamilyPosition.ROOT_RIGHT : types_1.FamilyPosition.RIGHT;
+            return this.left || this.right ? 'ROOT_RIGHT' : 'RIGHT';
         }
-        return types_1.FamilyPosition.MAL_NODE;
+        return 'MAL_NODE';
     }
 }
 exports.BinaryTreeNode = BinaryTreeNode;
@@ -106,8 +105,8 @@ class BinaryTree extends base_1.IterableEntryBase {
      */
     constructor(keysOrNodesOrEntries = [], options) {
         super();
-        this.iterationType = types_1.IterationType.ITERATIVE;
-        this._extractor = (key) => Number(key);
+        this.iterationType = 'ITERATIVE';
+        this._extractor = (key) => (typeof key === 'number' ? key : Number(key));
         this._defaultOneParamCallback = (node) => (node ? node.key : undefined);
         if (options) {
             const { iterationType, extractor } = options;
@@ -213,11 +212,11 @@ class BinaryTree extends base_1.IterableEntryBase {
      * `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, iterationType = types_1.IterationType.ITERATIVE) {
+    ensureNode(keyOrNodeOrEntry, iterationType = 'ITERATIVE') {
         let res;
         if (this.isRealNode(keyOrNodeOrEntry)) {
             res = keyOrNodeOrEntry;
@@ -444,10 +443,10 @@ class BinaryTree extends base_1.IterableEntryBase {
         }
         else if (parent) {
             const { familyPosition: fp } = curr;
-            if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
+            if (fp === 'LEFT' || fp === 'ROOT_LEFT') {
                 parent.left = curr.right;
             }
-            else if (fp === types_1.FamilyPosition.RIGHT || fp === types_1.FamilyPosition.ROOT_RIGHT) {
+            else if (fp === 'RIGHT' || fp === 'ROOT_RIGHT') {
                 parent.right = curr.right;
             }
             needBalanced = parent;
@@ -496,7 +495,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _traverse = (cur) => {
                 if (callback(cur) === identifier) {
                     ans.push(cur);
@@ -576,10 +575,10 @@ class BinaryTree extends base_1.IterableEntryBase {
      * @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 = types_1.IterationType.ITERATIVE) {
+    getNodeByKey(key, iterationType = 'ITERATIVE') {
         if (!this.root)
             return undefined;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _dfs = (cur) => {
                 if (cur.key === key)
                     return cur;
@@ -734,7 +733,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return true;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const dfs = (cur, min, max) => {
                 if (!this.isRealNode(cur))
                     return true;
@@ -821,9 +820,9 @@ class BinaryTree extends base_1.IterableEntryBase {
      */
     getHeight(beginRoot = this.root, iterationType = this.iterationType) {
         beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
+        if (!this.isRealNode(beginRoot))
             return -1;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _getMaxHeight = (cur) => {
                 if (!this.isRealNode(cur))
                     return -1;
@@ -869,11 +868,11 @@ class BinaryTree extends base_1.IterableEntryBase {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return -1;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _getMinHeight = (cur) => {
-                if (!cur)
+                if (!this.isRealNode(cur))
                     return 0;
-                if (!cur.left && !cur.right)
+                if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return 0;
                 const leftMinHeight = _getMinHeight(cur.left);
                 const rightMinHeight = _getMinHeight(cur.right);
@@ -886,17 +885,17 @@ class BinaryTree extends base_1.IterableEntryBase {
             let node = beginRoot, last = null;
             const depths = 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 ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            const rightMinHeight = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                        if (this.isRealNode(node)) {
+                            const leftMinHeight = this.isRealNode(node.left) ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
+                            const rightMinHeight = this.isRealNode(node.right) ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
                             depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
                             last = node;
                             node = null;
@@ -962,10 +961,12 @@ class BinaryTree extends base_1.IterableEntryBase {
      * is no leftmost node, it returns `null` or `undefined` depending on the input.
      */
     getLeftMost(beginRoot = this.root, iterationType = this.iterationType) {
+        if (this.isNIL(beginRoot))
+            return beginRoot;
         beginRoot = this.ensureNode(beginRoot);
-        if (!beginRoot)
+        if (!this.isRealNode(beginRoot))
             return beginRoot;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _traverse = (cur) => {
                 if (!this.isRealNode(cur.left))
                     return cur;
@@ -1003,11 +1004,13 @@ class BinaryTree extends base_1.IterableEntryBase {
      * is no rightmost node, it returns `null` or `undefined`, depending on the input.
      */
     getRightMost(beginRoot = this.root, iterationType = this.iterationType) {
+        if (this.isNIL(beginRoot))
+            return beginRoot;
         // TODO support get right most by passing key in
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return beginRoot;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _traverse = (cur) => {
                 if (!this.isRealNode(cur.right))
                     return cur;
@@ -1107,12 +1110,12 @@ class BinaryTree extends base_1.IterableEntryBase {
      * `false`, null or undefined
      * @returns an array of values that are the return values of the callback function.
      */
-    dfs(callback = this._defaultOneParamCallback, pattern = 'in', beginRoot = this.root, iterationType = types_1.IterationType.ITERATIVE, includeNull = false) {
+    dfs(callback = this._defaultOneParamCallback, pattern = 'in', beginRoot = this.root, iterationType = 'ITERATIVE', includeNull = false) {
         beginRoot = this.ensureNode(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _traverse = (node) => {
                 switch (pattern) {
                     case 'in':
@@ -1243,7 +1246,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const queue = new queue_1.Queue([beginRoot]);
             const traverse = (level) => {
                 if (queue.size === 0)
@@ -1320,7 +1323,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         const levelsNodes = [];
         if (!beginRoot)
             return levelsNodes;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _recursive = (node, level) => {
                 if (!levelsNodes[level])
                     levelsNodes[level] = [];
@@ -1607,7 +1610,7 @@ class BinaryTree extends base_1.IterableEntryBase {
     *_getIterator(node = this.root) {
         if (!node)
             return;
-        if (this.iterationType === types_1.IterationType.ITERATIVE) {
+        if (this.iterationType === 'ITERATIVE') {
             const stack = [];
             let current = node;
             while (current || stack.length > 0) {

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

@@ -109,10 +109,10 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * @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: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: IterationType): NODE | undefined;
+    ensureNode(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>, iterationType?: string): NODE | undefined;
     /**
      * The function checks if an keyOrNodeOrEntry is an instance of BSTNode.
      * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter is a variable of type `KeyOrNodeOrEntry<K, V, NODE>`.
@@ -179,7 +179,7 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * @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): NODE | undefined;
+    getNodeByKey(key: K, iterationType?: string): NODE | undefined;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(k + log n)
@@ -372,8 +372,10 @@ export declare class BST<K = any, V = any, NODE extends BSTNode<K, V, NODE> = BS
      * 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;
+    protected _lt(a: K, b: K): boolean;
+    protected _gt(a: K, b: K): boolean;
 }

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BST = exports.BSTNode = void 0;
-const types_1 = require("../../types");
 const binary_tree_1 = require("./binary-tree");
 const queue_1 = require("../queue");
 class BSTNode extends binary_tree_1.BinaryTreeNode {
@@ -70,7 +69,7 @@ class BST extends binary_tree_1.BinaryTree {
      */
     constructor(keysOrNodesOrEntries = [], options) {
         super([], options);
-        this._variant = types_1.BSTVariant.STANDARD;
+        this._variant = 'STANDARD';
         if (options) {
             const { variant } = options;
             if (variant)
@@ -162,10 +161,10 @@ class BST extends binary_tree_1.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 = types_1.IterationType.ITERATIVE) {
+    ensureNode(keyOrNodeOrEntry, iterationType = 'ITERATIVE') {
         let res;
         if (this.isRealNode(keyOrNodeOrEntry)) {
             res = keyOrNodeOrEntry;
@@ -215,7 +214,7 @@ class BST extends binary_tree_1.BinaryTree {
         }
         let current = this.root;
         while (current !== undefined) {
-            if (this._compare(current.key, newNode.key) === types_1.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);
@@ -226,7 +225,7 @@ class BST extends binary_tree_1.BinaryTree {
                 //   return;
                 // }
             }
-            else if (this._compare(current.key, newNode.key) === types_1.CP.gt) {
+            else if (this._compare(current.key, newNode.key) === 'GT') {
                 if (current.left === undefined) {
                     current.left = newNode;
                     this._size++;
@@ -335,7 +334,7 @@ class BST extends binary_tree_1.BinaryTree {
                 }
             }
         };
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             _dfs(sorted);
         }
         else {
@@ -361,18 +360,18 @@ class BST extends binary_tree_1.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 = types_1.IterationType.ITERATIVE) {
-        if (!this.root)
+    getNodeByKey(key, iterationType = 'ITERATIVE') {
+        if (!this.isRealNode(this.root))
             return undefined;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _dfs = (cur) => {
                 if (cur.key === key)
                     return cur;
-                if (!cur.left && !cur.right)
+                if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
-                if (this._compare(cur.key, key) === types_1.CP.gt && cur.left)
+                if (this._compare(cur.key, key) === 'GT' && this.isRealNode(cur.left))
                     return _dfs(cur.left);
-                if (this._compare(cur.key, key) === types_1.CP.lt && cur.right)
+                if (this._compare(cur.key, key) === 'LT' && this.isRealNode(cur.right))
                     return _dfs(cur.right);
             };
             return _dfs(this.root);
@@ -381,13 +380,13 @@ class BST extends binary_tree_1.BinaryTree {
             const queue = new queue_1.Queue([this.root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
-                if (cur) {
-                    if (this._compare(cur.key, key) === types_1.CP.eq)
+                if (this.isRealNode(cur)) {
+                    if (this._compare(cur.key, key) === 'EQ')
                         return cur;
-                    if (this._compare(cur.key, key) === types_1.CP.gt)
-                        cur.left && queue.push(cur.left);
-                    if (this._compare(cur.key, key) === types_1.CP.lt)
-                        cur.right && queue.push(cur.right);
+                    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);
                 }
             }
         }
@@ -425,7 +424,7 @@ class BST extends binary_tree_1.BinaryTree {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _traverse = (cur) => {
                 const callbackResult = callback(cur);
                 if (callbackResult === identifier) {
@@ -433,27 +432,27 @@ class BST extends binary_tree_1.BinaryTree {
                     if (onlyOne)
                         return;
                 }
-                if (!cur.left && !cur.right)
+                if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
                 // TODO potential bug
                 if (callback === this._defaultOneParamCallback) {
-                    if (this._compare(cur.key, identifier) === types_1.CP.gt)
-                        cur.left && _traverse(cur.left);
-                    if (this._compare(cur.key, identifier) === types_1.CP.lt)
-                        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 {
-                    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_1.Queue([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);
@@ -462,14 +461,20 @@ class BST extends binary_tree_1.BinaryTree {
                     }
                     // TODO potential bug
                     if (callback === this._defaultOneParamCallback) {
-                        if (this._compare(cur.key, identifier) === types_1.CP.gt)
-                            cur.left && queue.push(cur.left);
-                        if (this._compare(cur.key, identifier) === types_1.CP.lt)
-                            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 {
-                        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);
                     }
                 }
             }
@@ -499,7 +504,7 @@ class BST extends binary_tree_1.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 = types_1.IterationType.ITERATIVE) {
+    dfs(callback = this._defaultOneParamCallback, pattern = 'in', beginRoot = this.root, iterationType = 'ITERATIVE') {
         return super.dfs(callback, pattern, beginRoot, iterationType, false);
     }
     /**
@@ -572,7 +577,7 @@ class BST extends binary_tree_1.BinaryTree {
         let current = this.ensureNode(beginRoot);
         if (!current)
             return undefined;
-        if (this._variant === types_1.BSTVariant.STANDARD) {
+        if (this._variant === 'STANDARD') {
             // For BSTVariant.MIN, find the rightmost node
             while (current.right !== undefined) {
                 current = current.right;
@@ -611,7 +616,7 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The function `lesserOrGreaterTraverse` returns an array of values of type
      * `ReturnType<C>`, which is the return type of the callback function passed as an argument.
      */
-    lesserOrGreaterTraverse(callback = this._defaultOneParamCallback, lesserOrGreater = types_1.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)
@@ -619,7 +624,7 @@ class BST extends binary_tree_1.BinaryTree {
         if (!this.root)
             return ans;
         const targetKey = targetNode.key;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _traverse = (cur) => {
                 const compared = this._compare(cur.key, targetKey);
                 if (compared === lesserOrGreater)
@@ -669,7 +674,7 @@ class BST extends binary_tree_1.BinaryTree {
         this.clear();
         if (sorted.length < 1)
             return false;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -727,7 +732,7 @@ class BST extends binary_tree_1.BinaryTree {
         if (!this.root)
             return true;
         let balanced = true;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const _height = (cur) => {
                 if (!cur)
                     return 0;
@@ -784,14 +789,30 @@ class BST extends binary_tree_1.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 === types_1.BSTVariant.STANDARD ? extractedA - extractedB : extractedB - extractedA;
-        return compared > 0 ? types_1.CP.gt : compared < 0 ? types_1.CP.lt : types_1.CP.eq;
+        const compared = this.variant === 'STANDARD' ? extractedA - extractedB : extractedB - extractedA;
+        return compared > 0 ? 'GT' : compared < 0 ? 'LT' : 'EQ';
+    }
+    _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;
+    }
+    _gt(a, b) {
+        const extractedA = this.extractor(a);
+        const extractedB = this.extractor(b);
+        // return this.variant === BSTVariant.STANDARD  ? extractedA > extractedB : extractedA < extractedB;
+        return this.variant === 'STANDARD' ? extractedA > extractedB : extractedA < extractedB;
+        // return extractedA > extractedB;
+        // return a > b;
     }
 }
 exports.BST = BST;

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

@@ -1,5 +1,5 @@
 import type { BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry, RBTreeOptions, RedBlackTreeNested, RedBlackTreeNodeNested } from '../../types';
-import { RBTNColor } from '../../types';
+import { CRUD, RBTNColor } from '../../types';
 import { BST, BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<K = any, V = any, NODE extends RedBlackTreeNode<K, V, NODE> = RedBlackTreeNodeNested<K, V>> extends BSTNode<K, V, NODE> {
@@ -51,12 +51,6 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * @returns The root node of the tree structure, or undefined if there is no root node.
      */
     get root(): NODE | undefined;
-    protected _size: number;
-    /**
-     * The function returns the size of an object.
-     * @returns The size of the object, which is a number.
-     */
-    get size(): number;
     /**
      * The function creates a new Red-Black Tree node with the specified key, value, and color.
      * @param {K} key - The key parameter represents the key of the node being created. It is of type K,
@@ -236,7 +230,7 @@ export declare class RedBlackTree<K = any, V = any, NODE extends RedBlackTreeNod
      * node in the tree.
      * @returns {'inserted' | 'updated'} - The result of the insertion.
      */
-    protected _insert(node: NODE): 'inserted' | 'updated';
+    protected _insert(node: NODE): CRUD;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)