avl-tree-typed 1.50.7 → 1.50.9

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

@@ -5,8 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, KeyOrNodeOrEntry } from '../../types';
-import { IterationType } from '../../types';
+import type { AVLTreeMultiMapNested, AVLTreeMultiMapNodeNested, AVLTreeMultiMapOptions, BinaryTreeDeleteResult, BSTNKeyOrNode, BTNCallback, IterationType, KeyOrNodeOrEntry } 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,7 +45,19 @@ 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;
+    /**
+     * 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;
     /**
      * 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

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 {
     /**
@@ -55,7 +54,19 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
     get count() {
         return this._count;
     }
-    getMutableCount() {
+    /**
+     * 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() {
         let sum = 0;
         this.dfs(node => (sum += node.count));
         return sum;
@@ -205,10 +216,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;
@@ -271,11 +282,11 @@ class AVLTreeMultiMap extends avl_tree_1.AVLTree {
      * @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;
         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,7 +135,7 @@ 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.
      */

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;
@@ -823,7 +822,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         beginRoot = this.ensureNode(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,7 +868,7 @@ 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 (!this.isRealNode(cur))
                     return 0;
@@ -967,7 +966,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         beginRoot = this.ensureNode(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;
@@ -1011,7 +1010,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         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;
@@ -1111,15 +1110,15 @@ 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':
+                    case 'IN':
                         if (includeNull) {
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                                 _traverse(node.left);
@@ -1135,7 +1134,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                                 _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))
@@ -1151,7 +1150,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                                 _traverse(node.right);
                         }
                         break;
-                    case 'post':
+                    case 'POST':
                         if (includeNull) {
                             if (this.isRealNode(node) && this.isNodeOrNull(node.left))
                                 _traverse(node.left);
@@ -1191,17 +1190,17 @@ class BinaryTree extends base_1.IterableEntryBase {
                 }
                 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 });
@@ -1247,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)
@@ -1324,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] = [];
@@ -1391,7 +1390,7 @@ class BinaryTree extends base_1.IterableEntryBase {
      * `callback` function on each node in the binary tree. The type of the array nodes is determined
      * by the return type of the `callback` function.
      */
-    morris(callback = this._defaultOneParamCallback, pattern = 'in', beginRoot = this.root) {
+    morris(callback = this._defaultOneParamCallback, pattern = 'IN', beginRoot = this.root) {
         beginRoot = this.ensureNode(beginRoot);
         if (beginRoot === null)
             return [];
@@ -1418,7 +1417,7 @@ class BinaryTree extends base_1.IterableEntryBase {
             _reverseEdge(tail);
         };
         switch (pattern) {
-            case 'in':
+            case 'IN':
                 while (cur) {
                     if (cur.left) {
                         const predecessor = this.getPredecessor(cur);
@@ -1435,7 +1434,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                     cur = cur.right;
                 }
                 break;
-            case 'pre':
+            case 'PRE':
                 while (cur) {
                     if (cur.left) {
                         const predecessor = this.getPredecessor(cur);
@@ -1455,7 +1454,7 @@ class BinaryTree extends base_1.IterableEntryBase {
                     cur = cur.right;
                 }
                 break;
-            case 'post':
+            case 'POST':
                 while (cur) {
                     if (cur.left) {
                         const predecessor = this.getPredecessor(cur);
@@ -1611,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,7 +109,7 @@ 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;
@@ -372,8 +372,27 @@ 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;
+    /**
+     * 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;
+    /**
+     * 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;
 }

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,19 @@ 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) {
+    getNodeByKey(key, iterationType = 'ITERATIVE') {
+        // return this.getNodes(key, this._defaultOneParamCallback, true, this.root, iterationType)[0];
         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 (!this.isRealNode(cur.left) && !this.isRealNode(cur.right))
                     return;
-                if (this._compare(cur.key, key) === types_1.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) === types_1.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);
@@ -382,11 +382,11 @@ class BST extends binary_tree_1.BinaryTree {
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (this.isRealNode(cur)) {
-                    if (this._compare(cur.key, key) === types_1.CP.eq)
+                    if (this._compare(cur.key, key) === 'EQ')
                         return cur;
-                    if (this._compare(cur.key, key) === types_1.CP.gt)
+                    if (this._compare(cur.key, key) === 'GT')
                         this.isRealNode(cur.left) && queue.push(cur.left);
-                    if (this._compare(cur.key, key) === types_1.CP.lt)
+                    if (this._compare(cur.key, key) === 'LT')
                         this.isRealNode(cur.right) && queue.push(cur.right);
                 }
             }
@@ -425,7 +425,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) {
@@ -437,10 +437,10 @@ class BST extends binary_tree_1.BinaryTree {
                     return;
                 // TODO potential bug
                 if (callback === this._defaultOneParamCallback) {
-                    if (this._compare(cur.key, identifier) === types_1.CP.gt)
-                        this.isRealNode(cur.left) && _traverse(cur.left);
-                    if (this._compare(cur.key, identifier) === types_1.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);
@@ -450,9 +450,9 @@ class BST extends binary_tree_1.BinaryTree {
             _traverse(beginRoot);
         }
         else {
-            const queue = new queue_1.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) {
@@ -462,14 +462,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)
-                            this.isRealNode(cur.left) && queue.push(cur.left);
-                        if (this._compare(cur.key, identifier) === types_1.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);
                     }
                 }
             }
@@ -499,7 +505,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 +578,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 +617,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 +625,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)
@@ -665,11 +671,11 @@ class BST extends binary_tree_1.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 === types_1.IterationType.RECURSIVE) {
+        if (iterationType === 'RECURSIVE') {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -727,7 +733,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 +790,47 @@ 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';
+    }
+    /**
+     * 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;
     }
 }
 exports.BST = BST;