data-structure-typed 1.43.1 → 1.44.0

package/dist/mjs/{src/data-structures → data-structures}/binary-tree/binary-tree.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * data-structure-typed
  *
@@ -6,17 +5,15 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-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");
+import { FamilyPosition, IterationType } from '../../types';
+import { trampoline } from '../../utils';
+import { Queue } from '../queue';
 /**
  * Represents a node in a binary tree.
  * @template V - The type of data stored in the node.
  * @template N - The type of the family relationship in the binary tree.
  */
-class BinaryTreeNode {
+export class BinaryTreeNode {
     /**
      * The key associated with the node.
      */
@@ -79,31 +76,30 @@ 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 ? FamilyPosition.ROOT : FamilyPosition.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 ? FamilyPosition.ROOT_LEFT : FamilyPosition.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 ? FamilyPosition.ROOT_RIGHT : FamilyPosition.RIGHT;
         }
-        return types_1.FamilyPosition.MAL_NODE;
+        return FamilyPosition.MAL_NODE;
     }
 }
-exports.BinaryTreeNode = BinaryTreeNode;
 /**
  * Represents a binary tree data structure.
  * @template N - The type of the binary tree's nodes.
  */
-class BinaryTree {
-    iterationType = types_1.IterationType.ITERATIVE;
+export class BinaryTree {
+    iterationType = IterationType.ITERATIVE;
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options) {
         if (options) {
-            const { iterationType = types_1.IterationType.ITERATIVE } = options;
+            const { iterationType = IterationType.ITERATIVE } = options;
             this.iterationType = iterationType;
         }
         this._size = 0;
@@ -151,7 +147,7 @@ class BinaryTree {
      */
     add(keyOrNode, value) {
         const _bfs = (root, newNode) => {
-            const queue = new queue_1.Queue([root]);
+            const queue = new Queue([root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (newNode && cur.key === newNode.key) {
@@ -284,10 +280,10 @@ class BinaryTree {
             }
             else {
                 const { familyPosition: fp } = curr;
-                if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
+                if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
                     parent.left = curr.right;
                 }
-                else if (fp === types_1.FamilyPosition.RIGHT || fp === types_1.FamilyPosition.ROOT_RIGHT) {
+                else if (fp === FamilyPosition.RIGHT || fp === FamilyPosition.ROOT_RIGHT) {
                     parent.right = curr.right;
                 }
                 needBalanced = parent;
@@ -366,7 +362,7 @@ class BinaryTree {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return -1;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _getMaxHeight = (cur) => {
                 if (!cur)
                     return -1;
@@ -412,7 +408,7 @@ class BinaryTree {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return -1;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _getMinHeight = (cur) => {
                 if (!cur)
                     return 0;
@@ -506,7 +502,7 @@ class BinaryTree {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (callback(cur) === identifier) {
                     ans.push(cur);
@@ -521,7 +517,7 @@ class BinaryTree {
             _traverse(beginRoot);
         }
         else {
-            const queue = new queue_1.Queue([beginRoot]);
+            const queue = new Queue([beginRoot]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
@@ -614,10 +610,10 @@ class BinaryTree {
      * @returns The function `getNodeByKey` returns a node (`N`) 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 = IterationType.ITERATIVE) {
         if (!this.root)
             return undefined;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _dfs = (cur) => {
                 if (cur.key === key)
                     return cur;
@@ -631,7 +627,7 @@ class BinaryTree {
             return _dfs(this.root);
         }
         else {
-            const queue = new queue_1.Queue([this.root]);
+            const queue = new Queue([this.root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
@@ -654,7 +650,7 @@ class BinaryTree {
      * @returns either the node corresponding to the given key if it is a valid node key, or the key
      * itself if it is not a valid node key.
      */
-    ensureNotKey(key, iterationType = types_1.IterationType.ITERATIVE) {
+    ensureNotKey(key, iterationType = IterationType.ITERATIVE) {
         return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
     }
     /**
@@ -757,7 +753,7 @@ class BinaryTree {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return beginRoot;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (!this.isRealNode(cur.left))
                     return cur;
@@ -767,7 +763,7 @@ class BinaryTree {
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = (0, utils_1.trampoline)((cur) => {
+            const _traverse = trampoline((cur) => {
                 if (!this.isRealNode(cur.left))
                     return cur;
                 return _traverse.cont(cur.left);
@@ -799,7 +795,7 @@ class BinaryTree {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return beginRoot;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (!this.isRealNode(cur.right))
                     return cur;
@@ -809,7 +805,7 @@ class BinaryTree {
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = (0, utils_1.trampoline)((cur) => {
+            const _traverse = trampoline((cur) => {
                 if (!this.isRealNode(cur.right))
                     return cur;
                 return _traverse.cont(cur.right);
@@ -838,7 +834,7 @@ class BinaryTree {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return true;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const dfs = (cur, min, max) => {
                 if (!cur)
                     return true;
@@ -916,7 +912,7 @@ class BinaryTree {
         const ans = [];
         if (!beginRoot)
             return ans;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (cur !== undefined) {
                     ans.push(callback(cur));
@@ -1012,12 +1008,12 @@ class BinaryTree {
      * `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 = IterationType.ITERATIVE, includeNull = false) {
         beginRoot = this.ensureNotKey(beginRoot);
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (node) => {
                 switch (pattern) {
                     case 'in':
@@ -1148,8 +1144,8 @@ class BinaryTree {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === types_1.IterationType.RECURSIVE) {
-            const queue = new queue_1.Queue([beginRoot]);
+        if (iterationType === IterationType.RECURSIVE) {
+            const queue = new Queue([beginRoot]);
             const traverse = (level) => {
                 if (queue.size === 0)
                     return;
@@ -1172,7 +1168,7 @@ class BinaryTree {
             traverse(0);
         }
         else {
-            const queue = new queue_1.Queue([beginRoot]);
+            const queue = new Queue([beginRoot]);
             while (queue.size > 0) {
                 const levelSize = queue.size;
                 for (let i = 0; i < levelSize; i++) {
@@ -1225,7 +1221,7 @@ class BinaryTree {
         const levelsNodes = [];
         if (!beginRoot)
             return levelsNodes;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _recursive = (node, level) => {
                 if (!levelsNodes[level])
                     levelsNodes[level] = [];
@@ -1432,7 +1428,7 @@ class BinaryTree {
         if (!node) {
             return;
         }
-        if (this.iterationType === types_1.IterationType.ITERATIVE) {
+        if (this.iterationType === IterationType.ITERATIVE) {
             const stack = [];
             let current = node;
             while (current || stack.length > 0) {
@@ -1457,6 +1453,68 @@ class BinaryTree {
             }
         }
     }
+    /**
+     * The `print` function is used to display a binary tree structure in a visually appealing way.
+     * @param {N | null | undefined} root - The `root` parameter is of type `BTNKey | N | null |
+     * undefined`. It represents the root node of a binary tree. The root node can have one of the
+     * following types:
+     */
+    print(beginRoot = this.root) {
+        beginRoot = this.ensureNotKey(beginRoot);
+        if (!beginRoot)
+            return;
+        const display = (root) => {
+            const [lines, , ,] = _displayAux(root);
+            for (const line of lines) {
+                console.log(line);
+            }
+        };
+        const _displayAux = (node) => {
+            if (!this.isRealNode(node)) {
+                return [[], 0, 0, 0];
+            }
+            if (this.isRealNode(node) && !this.isRealNode(node.right) && !this.isRealNode(node.left)) {
+                const line = `${node.key}`;
+                const width = line.length;
+                const height = 1;
+                const middle = Math.floor(width / 2);
+                return [[line], width, height, middle];
+            }
+            if (this.isRealNode(node) && !this.isRealNode(node.right)) {
+                const [lines, n, p, x] = _displayAux(node.left);
+                const s = `${node.key}`;
+                const u = s.length;
+                const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
+                const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
+                const shifted_lines = lines.map(line => line + ' '.repeat(u));
+                return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
+            }
+            if (this.isRealNode(node) && !this.isRealNode(node.left)) {
+                const [lines, n, p, u] = _displayAux(node.right);
+                const s = `${node.key}`;
+                const x = s.length;
+                const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
+                const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
+                const shifted_lines = lines.map(line => ' '.repeat(u) + line);
+                return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
+            }
+            const [left, n, p, x] = _displayAux(node.left);
+            const [right, m, q, y] = _displayAux(node.right);
+            const s = `${node.key}`;
+            const u = s.length;
+            const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
+            const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
+            if (p < q) {
+                left.push(...new Array(q - p).fill(' '.repeat(n)));
+            }
+            else if (q < p) {
+                right.push(...new Array(p - q).fill(' '.repeat(m)));
+            }
+            const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
+            return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
+        };
+        display(beginRoot);
+    }
     _defaultOneParamCallback = (node) => node.key;
     /**
      * Swap the data of two nodes in the binary tree.
@@ -1531,67 +1589,4 @@ class BinaryTree {
         }
         this._root = v;
     }
-    /**
-     * The `print` function is used to display a binary tree structure in a visually appealing way.
-     * @param {N | null | undefined} root - The `root` parameter is of type `BTNKey | N | null |
-     * undefined`. It represents the root node of a binary tree. The root node can have one of the
-     * following types:
-     */
-    print(beginRoot = this.root) {
-        beginRoot = this.ensureNotKey(beginRoot);
-        if (!beginRoot)
-            return;
-        const display = (root) => {
-            const [lines, , ,] = _displayAux(root);
-            for (const line of lines) {
-                console.log(line);
-            }
-        };
-        const _displayAux = (node) => {
-            if (!this.isRealNode(node)) {
-                return [[], 0, 0, 0];
-            }
-            if (this.isRealNode(node) && !this.isRealNode(node.right) && !this.isRealNode(node.left)) {
-                const line = `${node.key}`;
-                const width = line.length;
-                const height = 1;
-                const middle = Math.floor(width / 2);
-                return [[line], width, height, middle];
-            }
-            if (this.isRealNode(node) && !this.isRealNode(node.right)) {
-                const [lines, n, p, x] = _displayAux(node.left);
-                const s = `${node.key}`;
-                const u = s.length;
-                const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s;
-                const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u);
-                const shifted_lines = lines.map(line => line + ' '.repeat(u));
-                return [[first_line, second_line, ...shifted_lines], n + u, p + 2, n + Math.floor(u / 2)];
-            }
-            if (this.isRealNode(node) && !this.isRealNode(node.left)) {
-                const [lines, n, p, u] = _displayAux(node.right);
-                const s = `${node.key}`;
-                const x = s.length;
-                const first_line = s + '_'.repeat(x) + ' '.repeat(n - x);
-                const second_line = ' '.repeat(u + x) + '\\' + ' '.repeat(n - x - 1);
-                const shifted_lines = lines.map(line => ' '.repeat(u) + line);
-                return [[first_line, second_line, ...shifted_lines], n + x, p + 2, Math.floor(u / 2)];
-            }
-            const [left, n, p, x] = _displayAux(node.left);
-            const [right, m, q, y] = _displayAux(node.right);
-            const s = `${node.key}`;
-            const u = s.length;
-            const first_line = ' '.repeat(x + 1) + '_'.repeat(n - x - 1) + s + '_'.repeat(y) + ' '.repeat(m - y);
-            const second_line = ' '.repeat(x) + '/' + ' '.repeat(n - x - 1 + u + y) + '\\' + ' '.repeat(m - y - 1);
-            if (p < q) {
-                left.push(...new Array(q - p).fill(' '.repeat(n)));
-            }
-            else if (q < p) {
-                right.push(...new Array(p - q).fill(' '.repeat(m)));
-            }
-            const zipped_lines = left.map((a, i) => a + ' '.repeat(u) + right[i]);
-            return [[first_line, second_line, ...zipped_lines], n + m + u, Math.max(p, q) + 2, n + Math.floor(u / 2)];
-        };
-        display(beginRoot);
-    }
 }
-exports.BinaryTree = BinaryTree;

package/dist/mjs/{src/data-structures → data-structures}/binary-tree/bst.js

@@ -1,10 +1,7 @@
-"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 {
+import { CP, IterationType } from '../../types';
+import { BinaryTree, BinaryTreeNode } from './binary-tree';
+import { Queue } from '../queue';
+export class BSTNode extends BinaryTreeNode {
     parent;
     constructor(key, value) {
         super(key, value);
@@ -47,8 +44,7 @@ class BSTNode extends binary_tree_1.BinaryTreeNode {
         this._right = v;
     }
 }
-exports.BSTNode = BSTNode;
-class BST extends binary_tree_1.BinaryTree {
+export class BST extends BinaryTree {
     /**
      * The constructor function initializes a binary search tree with an optional comparator function.
      * @param {BSTOptions} [options] - An optional object that contains additional configuration options
@@ -123,7 +119,7 @@ class BST extends binary_tree_1.BinaryTree {
             let traversing = true;
             while (traversing) {
                 if (cur !== undefined && newNode !== undefined) {
-                    if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
+                    if (this._compare(cur.key, newNode.key) === CP.eq) {
                         if (newNode) {
                             cur.value = newNode.value;
                         }
@@ -131,7 +127,7 @@ class BST extends binary_tree_1.BinaryTree {
                         traversing = false;
                         inserted = cur;
                     }
-                    else if (this._compare(cur.key, newNode.key) === types_1.CP.gt) {
+                    else if (this._compare(cur.key, newNode.key) === CP.gt) {
                         // Traverse left of the node
                         if (cur.left === undefined) {
                             if (newNode) {
@@ -149,7 +145,7 @@ class BST extends binary_tree_1.BinaryTree {
                                 cur = cur.left;
                         }
                     }
-                    else if (this._compare(cur.key, newNode.key) === types_1.CP.lt) {
+                    else if (this._compare(cur.key, newNode.key) === CP.lt) {
                         // Traverse right of the node
                         if (cur.right === undefined) {
                             if (newNode) {
@@ -260,7 +256,7 @@ class BST extends binary_tree_1.BinaryTree {
                 }
             }
         };
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             _dfs(sortedKeysOrNodes, sortedData);
         }
         else {
@@ -288,9 +284,9 @@ class BST extends binary_tree_1.BinaryTree {
      * rightmost node otherwise. If no node is found, it returns 0.
      */
     lastKey(beginRoot = this.root, iterationType = this.iterationType) {
-        if (this._compare(0, 1) === types_1.CP.lt)
+        if (this._compare(0, 1) === CP.lt)
             return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
-        else if (this._compare(0, 1) === types_1.CP.gt)
+        else if (this._compare(0, 1) === CP.gt)
             return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
         else
             return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
@@ -313,32 +309,32 @@ class BST extends binary_tree_1.BinaryTree {
      * @returns The function `getNodeByKey` returns a node (`N`) 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 = IterationType.ITERATIVE) {
         if (!this.root)
             return undefined;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _dfs = (cur) => {
                 if (cur.key === key)
                     return cur;
                 if (!cur.left && !cur.right)
                     return;
-                if (this._compare(cur.key, key) === types_1.CP.gt && cur.left)
+                if (this._compare(cur.key, key) === CP.gt && cur.left)
                     return _dfs(cur.left);
-                if (this._compare(cur.key, key) === types_1.CP.lt && cur.right)
+                if (this._compare(cur.key, key) === CP.lt && cur.right)
                     return _dfs(cur.right);
             };
             return _dfs(this.root);
         }
         else {
-            const queue = new queue_1.Queue([this.root]);
+            const queue = new 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._compare(cur.key, key) === CP.eq)
                         return cur;
-                    if (this._compare(cur.key, key) === types_1.CP.gt)
+                    if (this._compare(cur.key, key) === CP.gt)
                         cur.left && queue.push(cur.left);
-                    if (this._compare(cur.key, key) === types_1.CP.lt)
+                    if (this._compare(cur.key, key) === CP.lt)
                         cur.right && queue.push(cur.right);
                 }
             }
@@ -353,7 +349,7 @@ class BST extends binary_tree_1.BinaryTree {
      * type of iteration to be performed. It has a default value of `IterationType.ITERATIVE`.
      * @returns either a node object (N) or undefined.
      */
-    ensureNotKey(key, iterationType = types_1.IterationType.ITERATIVE) {
+    ensureNotKey(key, iterationType = IterationType.ITERATIVE) {
         return this.isNodeKey(key) ? this.getNodeByKey(key, iterationType) : key;
     }
     /**
@@ -388,7 +384,7 @@ class BST extends binary_tree_1.BinaryTree {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 const callbackResult = callback(cur);
                 if (callbackResult === identifier) {
@@ -400,9 +396,9 @@ 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)
+                    if (this._compare(cur.key, identifier) === CP.gt)
                         cur.left && _traverse(cur.left);
-                    if (this._compare(cur.key, identifier) === types_1.CP.lt)
+                    if (this._compare(cur.key, identifier) === CP.lt)
                         cur.right && _traverse(cur.right);
                 }
                 else {
@@ -413,7 +409,7 @@ class BST extends binary_tree_1.BinaryTree {
             _traverse(beginRoot);
         }
         else {
-            const queue = new queue_1.Queue([beginRoot]);
+            const queue = new Queue([beginRoot]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
@@ -425,9 +421,9 @@ class BST extends binary_tree_1.BinaryTree {
                     }
                     // TODO potential bug
                     if (callback === this._defaultOneParamCallback) {
-                        if (this._compare(cur.key, identifier) === types_1.CP.gt)
+                        if (this._compare(cur.key, identifier) === CP.gt)
                             cur.left && queue.push(cur.left);
-                        if (this._compare(cur.key, identifier) === types_1.CP.lt)
+                        if (this._compare(cur.key, identifier) === CP.lt)
                             cur.right && queue.push(cur.right);
                     }
                     else {
@@ -464,7 +460,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 = CP.lt, targetNode = this.root, iterationType = this.iterationType) {
         targetNode = this.ensureNotKey(targetNode);
         const ans = [];
         if (!targetNode)
@@ -472,7 +468,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 === IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 const compared = this._compare(cur.key, targetKey);
                 if (compared === lesserOrGreater)
@@ -488,7 +484,7 @@ class BST extends binary_tree_1.BinaryTree {
             return ans;
         }
         else {
-            const queue = new queue_1.Queue([this.root]);
+            const queue = new Queue([this.root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
@@ -533,7 +529,7 @@ class BST extends binary_tree_1.BinaryTree {
         this.clear();
         if (sorted.length < 1)
             return false;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -582,7 +578,7 @@ class BST extends binary_tree_1.BinaryTree {
         if (!this.root)
             return true;
         let balanced = true;
-        if (iterationType === types_1.IterationType.RECURSIVE) {
+        if (iterationType === IterationType.RECURSIVE) {
             const _height = (cur) => {
                 if (!cur)
                     return 0;
@@ -641,11 +637,10 @@ class BST extends binary_tree_1.BinaryTree {
     _compare(a, b) {
         const compared = this._comparator(a, b);
         if (compared > 0)
-            return types_1.CP.gt;
+            return CP.gt;
         else if (compared < 0)
-            return types_1.CP.lt;
+            return CP.lt;
         else
-            return types_1.CP.eq;
+            return CP.eq;
     }
 }
-exports.BST = BST;

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

@@ -0,0 +1,7 @@
+export * from './binary-tree';
+export * from './bst';
+export * from './binary-indexed-tree';
+export * from './segment-tree';
+export * from './avl-tree';
+export * from './rb-tree';
+export * from './tree-multimap';

package/dist/{cjs/src → mjs}/data-structures/binary-tree/rb-tree.d.ts

@@ -5,9 +5,9 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { BiTreeDeleteResult, BTNCallback, BTNKey, IterationType, RBTNColor, RedBlackTreeNodeNested, RBTreeOptions } from '../../types';
-import { BST, BSTNode } from "./bst";
-import { IBinaryTree } from "../../interfaces";
+import { BiTreeDeleteResult, BTNCallback, BTNKey, IterationType, RBTNColor, RBTreeOptions, RedBlackTreeNodeNested } from '../../types';
+import { BST, BSTNode } from './bst';
+import { IBinaryTree } from '../../interfaces';
 export declare class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNodeNested<V>> extends BSTNode<V, N> {
     color: RBTNColor;
     constructor(key: BTNKey, value?: V, color?: RBTNColor);
@@ -20,6 +20,7 @@ export declare class RedBlackTreeNode<V = any, N extends RedBlackTreeNode<V, N>
  * 5. Black balance: Every path from any node to each of its leaf nodes contains the same number of black nodes.
  */
 export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = RedBlackTreeNode<V, RedBlackTreeNodeNested<V>>> extends BST<V, N> implements IBinaryTree<V, N> {
+    NIL: N;
     /**
      * The constructor function initializes a Red-Black Tree with an optional set of options.
      * @param {RBTreeOptions} [options] - The `options` parameter is an optional object that can be
@@ -30,7 +31,6 @@ export declare class RedBlackTree<V = any, N extends RedBlackTreeNode<V, N> = Re
     get root(): N;
     protected _size: number;
     get size(): number;
-    NIL: N;
     /**
      * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
      * Space Complexity: O(1)