data-structure-typed 1.38.1 → 1.38.2

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * data-structure-typed
  *
@@ -5,15 +6,29 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { FamilyPosition, IterationType } from '../../types';
-import { trampoline } from '../../utils';
-import { Queue } from '../queue';
+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");
 /**
  * Represents a node in a binary tree.
  * @template V - The type of data stored in the node.
  * @template FAMILY - The type of the family relationship in the binary tree.
  */
-export class BinaryTreeNode {
+class BinaryTreeNode {
+    /**
+     * The key associated with the node.
+     */
+    key;
+    /**
+     * The value stored in the node.
+     */
+    val;
+    /**
+     * The parent node of the current node.
+     */
+    parent;
     /**
      * Creates a new instance of BinaryTreeNode.
      * @param {BinaryTreeNodeKey} key - The key associated with the node.
@@ -23,6 +38,7 @@ export class BinaryTreeNode {
         this.key = key;
         this.val = val;
     }
+    _left;
     /**
      * Get the left child node.
      */
@@ -39,6 +55,7 @@ export class BinaryTreeNode {
         }
         this._left = v;
     }
+    _right;
     /**
      * Get the right child node.
      */
@@ -64,66 +81,59 @@ export class BinaryTreeNode {
         if (that.parent) {
             if (that.parent.left === that) {
                 if (that.left || that.right) {
-                    return FamilyPosition.ROOT_LEFT;
+                    return types_1.FamilyPosition.ROOT_LEFT;
                 }
                 else {
-                    return FamilyPosition.LEFT;
+                    return types_1.FamilyPosition.LEFT;
                 }
             }
             else if (that.parent.right === that) {
                 if (that.left || that.right) {
-                    return FamilyPosition.ROOT_RIGHT;
+                    return types_1.FamilyPosition.ROOT_RIGHT;
                 }
                 else {
-                    return FamilyPosition.RIGHT;
+                    return types_1.FamilyPosition.RIGHT;
                 }
             }
             else {
-                return FamilyPosition.MAL_NODE;
+                return types_1.FamilyPosition.MAL_NODE;
             }
         }
         else {
             if (that.left || that.right) {
-                return FamilyPosition.ROOT;
+                return types_1.FamilyPosition.ROOT;
             }
             else {
-                return FamilyPosition.ISOLATED;
+                return types_1.FamilyPosition.ISOLATED;
             }
         }
     }
 }
+exports.BinaryTreeNode = BinaryTreeNode;
 /**
  * Represents a binary tree data structure.
  * @template N - The type of the binary tree's nodes.
  */
-export class BinaryTree {
+class BinaryTree {
+    _loopType = types_1.IterationType.ITERATIVE;
     /**
      * Creates a new instance of BinaryTree.
      * @param {BinaryTreeOptions} [options] - The options for the binary tree.
      */
     constructor(options) {
-        this._loopType = IterationType.ITERATIVE;
-        this._root = null;
-        this._size = 0;
-        /**
-         * Time complexity is O(n)
-         * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
-         * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
-         * the tree's structure should be restored to its original state to maintain the tree's integrity.
-         * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
-         */
-        this._defaultCallbackByKey = node => node.key;
         if (options !== undefined) {
-            const { iterationType = IterationType.ITERATIVE } = options;
+            const { iterationType = types_1.IterationType.ITERATIVE } = options;
             this._loopType = iterationType;
         }
     }
+    _root = null;
     /**
      * Get the root node of the binary tree.
      */
     get root() {
         return this._root;
     }
+    _size = 0;
     /**
      * Get the number of nodes in the binary tree.
      */
@@ -174,7 +184,7 @@ export class BinaryTree {
      */
     add(keyOrNode, val) {
         const _bfs = (root, newNode) => {
-            const queue = new Queue([root]);
+            const queue = new queue_1.Queue([root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
@@ -251,7 +261,7 @@ export class BinaryTree {
                 inserted.push(this.add(null));
                 continue;
             }
-            const val = values === null || values === void 0 ? void 0 : values[i];
+            const val = values?.[i];
             inserted.push(this.add(keyOrNode, val));
         }
         return inserted;
@@ -284,7 +294,7 @@ export class BinaryTree {
         const curr = typeof nodeOrKey === 'number' ? this.get(nodeOrKey) : nodeOrKey;
         if (!curr)
             return bstDeletedResult;
-        const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
+        const parent = curr?.parent ? curr.parent : null;
         let needBalanced = null, orgCurrent = curr;
         if (!curr.left) {
             if (!parent) {
@@ -293,10 +303,10 @@ export class BinaryTree {
             }
             else {
                 const { familyPosition: fp } = curr;
-                if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
+                if (fp === types_1.FamilyPosition.LEFT || fp === types_1.FamilyPosition.ROOT_LEFT) {
                     parent.left = curr.right;
                 }
-                else if (fp === FamilyPosition.RIGHT || fp === FamilyPosition.ROOT_RIGHT) {
+                else if (fp === types_1.FamilyPosition.RIGHT || fp === types_1.FamilyPosition.ROOT_RIGHT) {
                     parent.right = curr.right;
                 }
                 needBalanced = parent;
@@ -338,7 +348,7 @@ export class BinaryTree {
         if (typeof beginRoot === 'number')
             beginRoot = this.get(beginRoot);
         let depth = 0;
-        while (distNode === null || distNode === void 0 ? void 0 : distNode.parent) {
+        while (distNode?.parent) {
             if (distNode === beginRoot) {
                 return depth;
             }
@@ -364,7 +374,7 @@ export class BinaryTree {
             beginRoot = this.get(beginRoot);
         if (!beginRoot)
             return -1;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _getMaxHeight = (cur) => {
                 if (!cur)
                     return -1;
@@ -404,10 +414,9 @@ export class BinaryTree {
      * @returns The function `getMinHeight` returns the minimum height of a binary tree.
      */
     getMinHeight(beginRoot = this.root, iterationType = this.iterationType) {
-        var _a, _b, _c;
         if (!beginRoot)
             return -1;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _getMinHeight = (cur) => {
                 if (!cur)
                     return 0;
@@ -433,8 +442,8 @@ export class BinaryTree {
                     if (!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;
+                            const leftMinHeight = node.left ? depths.get(node.left) ?? -1 : -1;
+                            const rightMinHeight = node.right ? depths.get(node.right) ?? -1 : -1;
                             depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
                             last = node;
                             node = null;
@@ -444,7 +453,7 @@ export class BinaryTree {
                         node = node.right;
                 }
             }
-            return (_c = depths.get(beginRoot)) !== null && _c !== void 0 ? _c : -1;
+            return depths.get(beginRoot) ?? -1;
         }
     }
     /**
@@ -482,7 +491,7 @@ export class BinaryTree {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (callback(cur) === nodeProperty) {
                     ans.push(cur);
@@ -497,7 +506,7 @@ export class BinaryTree {
             _traverse(beginRoot);
         }
         else {
-            const queue = new Queue([beginRoot]);
+            const queue = new queue_1.Queue([beginRoot]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
@@ -550,9 +559,8 @@ export class BinaryTree {
      * @returns either the found node (of type N) or null if no node is found.
      */
     get(nodeProperty, callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
-        var _a;
         // TODO may support finding node by value equal
-        return (_a = this.getNodes(nodeProperty, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
+        return this.getNodes(nodeProperty, callback, true, beginRoot, iterationType)[0] ?? null;
     }
     /**
      * The function `getPathToRoot` returns an array of nodes starting from a given node and traversing
@@ -592,7 +600,7 @@ export class BinaryTree {
             beginRoot = this.get(beginRoot);
         if (!beginRoot)
             return beginRoot;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (!cur.left)
                     return cur;
@@ -602,7 +610,7 @@ export class BinaryTree {
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = trampoline((cur) => {
+            const _traverse = (0, utils_1.trampoline)((cur) => {
                 if (!cur.left)
                     return cur;
                 return _traverse.cont(cur.left);
@@ -625,7 +633,7 @@ export class BinaryTree {
         // TODO support get right most by passing key in
         if (!beginRoot)
             return beginRoot;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 if (!cur.right)
                     return cur;
@@ -635,7 +643,7 @@ export class BinaryTree {
         }
         else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = trampoline((cur) => {
+            const _traverse = (0, utils_1.trampoline)((cur) => {
                 if (!cur.right)
                     return cur;
                 return _traverse.cont(cur.right);
@@ -656,7 +664,7 @@ export class BinaryTree {
         // TODO there is a bug
         if (!beginRoot)
             return true;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const dfs = (cur, min, max) => {
                 if (!cur)
                     return true;
@@ -716,7 +724,7 @@ export class BinaryTree {
         const ans = [];
         if (!beginRoot)
             return ans;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 ans.push(callback(cur));
                 cur.left && _traverse(cur.left);
@@ -750,11 +758,11 @@ export class BinaryTree {
      * iteration used in the depth-first search algorithm. It can have two possible values:
      * @returns The function `dfs` returns an array of `MapCallbackReturn<N>` values.
      */
-    dfs(callback = this._defaultCallbackByKey, pattern = 'in', beginRoot = this.root, iterationType = IterationType.ITERATIVE) {
+    dfs(callback = this._defaultCallbackByKey, pattern = 'in', beginRoot = this.root, iterationType = types_1.IterationType.ITERATIVE) {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (node) => {
                 switch (pattern) {
                     case 'in':
@@ -841,7 +849,7 @@ export class BinaryTree {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _recursive = (node, level) => {
                 callback && ans.push(callback(node, withLevel ? level : undefined));
                 if (node.left)
@@ -1000,6 +1008,14 @@ export class BinaryTree {
         }
         return destNode;
     }
+    /**
+     * Time complexity is O(n)
+     * Space complexity of Iterative dfs equals to recursive dfs which is O(n) because of the stack
+     * The Morris algorithm only modifies the tree's structure during traversal; once the traversal is complete,
+     * the tree's structure should be restored to its original state to maintain the tree's integrity.
+     * This is because the purpose of the Morris algorithm is to save space rather than permanently alter the tree's shape.
+     */
+    _defaultCallbackByKey = node => node.key;
     /**
      * The function `_addTo` adds a new node to a binary tree if there is an available position.
      * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to
@@ -1058,3 +1074,4 @@ export class BinaryTree {
         this._size = v;
     }
 }
+exports.BinaryTree = BinaryTree;

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

@@ -1,12 +1,16 @@
-import { CP, IterationType } from '../../types';
-import { BinaryTree, BinaryTreeNode } from './binary-tree';
-import { Queue } from '../queue';
-export class BSTNode extends BinaryTreeNode {
+"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 {
     constructor(key, val) {
         super(key, val);
     }
 }
-export class BST extends BinaryTree {
+exports.BSTNode = BSTNode;
+class BST extends binary_tree_1.BinaryTree {
     /**
      * The constructor function initializes a binary search tree object with an optional comparator
      * function.
@@ -15,7 +19,6 @@ export class BST extends BinaryTree {
      */
     constructor(options) {
         super(options);
-        this._comparator = (a, b) => a - b;
         if (options !== undefined) {
             const { comparator } = options;
             if (comparator !== undefined) {
@@ -67,7 +70,7 @@ export class BST extends BinaryTree {
             let traversing = true;
             while (traversing) {
                 if (cur !== null && newNode !== null) {
-                    if (this._compare(cur.key, newNode.key) === CP.eq) {
+                    if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
                         if (newNode) {
                             cur.val = newNode.val;
                         }
@@ -75,7 +78,7 @@ export class BST extends BinaryTree {
                         traversing = false;
                         inserted = cur;
                     }
-                    else if (this._compare(cur.key, newNode.key) === CP.gt) {
+                    else if (this._compare(cur.key, newNode.key) === types_1.CP.gt) {
                         // Traverse left of the node
                         if (cur.left === undefined) {
                             if (newNode) {
@@ -93,7 +96,7 @@ export class BST extends BinaryTree {
                                 cur = cur.left;
                         }
                     }
-                    else if (this._compare(cur.key, newNode.key) === CP.lt) {
+                    else if (this._compare(cur.key, newNode.key) === types_1.CP.lt) {
                         // Traverse right of the node
                         if (cur.right === undefined) {
                             if (newNode) {
@@ -141,7 +144,7 @@ export class BST extends BinaryTree {
             return super.addMany(keysOrNodes, data);
         }
         const inserted = [];
-        const combinedArr = keysOrNodes.map((value, index) => [value, data === null || data === void 0 ? void 0 : data[index]]);
+        const combinedArr = keysOrNodes.map((value, index) => [value, data?.[index]]);
         let sorted = [];
         function isNodeOrNullTuple(arr) {
             for (const [keyOrNode] of arr)
@@ -171,10 +174,10 @@ export class BST extends BinaryTree {
             if (arr.length === 0)
                 return;
             const mid = Math.floor((arr.length - 1) / 2);
-            const newNode = this.add(arr[mid], data === null || data === void 0 ? void 0 : data[mid]);
+            const newNode = this.add(arr[mid], data?.[mid]);
             inserted.push(newNode);
-            recursive(arr.slice(0, mid), data === null || data === void 0 ? void 0 : data.slice(0, mid));
-            recursive(arr.slice(mid + 1), data === null || data === void 0 ? void 0 : data.slice(mid + 1));
+            recursive(arr.slice(0, mid), data?.slice(0, mid));
+            recursive(arr.slice(mid + 1), data?.slice(mid + 1));
         };
         const iterative = () => {
             const n = sorted.length;
@@ -185,7 +188,7 @@ export class BST extends BinaryTree {
                     const [l, r] = popped;
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
-                        const newNode = this.add(sortedKeysOrNodes[m], sortedData === null || sortedData === void 0 ? void 0 : sortedData[m]);
+                        const newNode = this.add(sortedKeysOrNodes[m], sortedData?.[m]);
                         inserted.push(newNode);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -193,7 +196,7 @@ export class BST extends BinaryTree {
                 }
             }
         };
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             recursive(sortedKeysOrNodes, sortedData);
         }
         else {
@@ -220,8 +223,7 @@ export class BST extends BinaryTree {
      * matching node is found.
      */
     get(nodeProperty, callback = this._defaultCallbackByKey, beginRoot = this.root, iterationType = this.iterationType) {
-        var _a;
-        return (_a = this.getNodes(nodeProperty, callback, true, beginRoot, iterationType)[0]) !== null && _a !== void 0 ? _a : null;
+        return this.getNodes(nodeProperty, callback, true, beginRoot, iterationType)[0] ?? null;
     }
     /**
      * The function `lastKey` returns the key of the rightmost node if the comparison result is less
@@ -239,13 +241,12 @@ export class BST extends BinaryTree {
      * rightmost node otherwise. If no node is found, it returns 0.
      */
     lastKey(beginRoot = this.root, iterationType = this.iterationType) {
-        var _a, _b, _c, _d, _e, _f;
-        if (this._compare(0, 1) === CP.lt)
-            return (_b = (_a = this.getRightMost(beginRoot, iterationType)) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : 0;
-        else if (this._compare(0, 1) === CP.gt)
-            return (_d = (_c = this.getLeftMost(beginRoot, iterationType)) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : 0;
+        if (this._compare(0, 1) === types_1.CP.lt)
+            return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
+        else if (this._compare(0, 1) === types_1.CP.gt)
+            return this.getLeftMost(beginRoot, iterationType)?.key ?? 0;
         else
-            return (_f = (_e = this.getRightMost(beginRoot, iterationType)) === null || _e === void 0 ? void 0 : _e.key) !== null && _f !== void 0 ? _f : 0;
+            return this.getRightMost(beginRoot, iterationType)?.key ?? 0;
     }
     /**
      * The function `getNodes` retrieves nodes from a binary tree based on a given node property or key,
@@ -272,7 +273,7 @@ export class BST extends BinaryTree {
         if (!beginRoot)
             return [];
         const ans = [];
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 const callbackResult = callback(cur);
                 if (callbackResult === nodeProperty) {
@@ -284,9 +285,9 @@ export class BST extends BinaryTree {
                     return;
                 // TODO potential bug
                 if (callback === this._defaultCallbackByKey) {
-                    if (this._compare(cur.key, nodeProperty) === CP.gt)
+                    if (this._compare(cur.key, nodeProperty) === types_1.CP.gt)
                         cur.left && _traverse(cur.left);
-                    if (this._compare(cur.key, nodeProperty) === CP.lt)
+                    if (this._compare(cur.key, nodeProperty) === types_1.CP.lt)
                         cur.right && _traverse(cur.right);
                 }
                 else {
@@ -297,7 +298,7 @@ export class BST extends BinaryTree {
             _traverse(beginRoot);
         }
         else {
-            const queue = new Queue([beginRoot]);
+            const queue = new queue_1.Queue([beginRoot]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
@@ -309,9 +310,9 @@ export class BST extends BinaryTree {
                     }
                     // TODO potential bug
                     if (callback === this._defaultCallbackByKey) {
-                        if (this._compare(cur.key, nodeProperty) === CP.gt)
+                        if (this._compare(cur.key, nodeProperty) === types_1.CP.gt)
                             cur.left && queue.push(cur.left);
-                        if (this._compare(cur.key, nodeProperty) === CP.lt)
+                        if (this._compare(cur.key, nodeProperty) === types_1.CP.lt)
                             cur.right && queue.push(cur.right);
                     }
                     else {
@@ -341,7 +342,7 @@ export class BST extends BinaryTree {
      * done recursively or iteratively. It can have two possible values:
      * @returns The function `lesserOrGreaterTraverse` returns an array of `MapCallbackReturn<N>`.
      */
-    lesserOrGreaterTraverse(callback = this._defaultCallbackByKey, lesserOrGreater = CP.lt, targetNode = this.root, iterationType = this.iterationType) {
+    lesserOrGreaterTraverse(callback = this._defaultCallbackByKey, lesserOrGreater = types_1.CP.lt, targetNode = this.root, iterationType = this.iterationType) {
         if (typeof targetNode === 'number')
             targetNode = this.get(targetNode);
         const ans = [];
@@ -350,7 +351,7 @@ export class BST extends BinaryTree {
         const targetKey = targetNode.key;
         if (!this.root)
             return ans;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _traverse = (cur) => {
                 const compared = this._compare(cur.key, targetKey);
                 if (compared === lesserOrGreater)
@@ -366,7 +367,7 @@ export class BST extends BinaryTree {
             return ans;
         }
         else {
-            const queue = new Queue([this.root]);
+            const queue = new queue_1.Queue([this.root]);
             while (queue.size > 0) {
                 const cur = queue.shift();
                 if (cur) {
@@ -404,7 +405,7 @@ export class BST extends BinaryTree {
         this.clear();
         if (sorted.length < 1)
             return false;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -442,11 +443,10 @@ export class BST extends BinaryTree {
      * @returns a boolean value.
      */
     isAVLBalanced(iterationType = this.iterationType) {
-        var _a, _b;
         if (!this.root)
             return true;
         let balanced = true;
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const _height = (cur) => {
                 if (!cur)
                     return 0;
@@ -471,8 +471,8 @@ export class BST extends BinaryTree {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            const left = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            const right = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                            const left = node.left ? depths.get(node.left) ?? -1 : -1;
+                            const right = node.right ? depths.get(node.right) ?? -1 : -1;
                             if (Math.abs(left - right) > 1)
                                 return false;
                             depths.set(node, 1 + Math.max(left, right));
@@ -487,6 +487,7 @@ export class BST extends BinaryTree {
         }
         return balanced;
     }
+    _comparator = (a, b) => a - b;
     /**
      * The function compares two values using a comparator function and returns whether the first value
      * is greater than, less than, or equal to the second value.
@@ -498,10 +499,11 @@ export class BST extends BinaryTree {
     _compare(a, b) {
         const compared = this._comparator(a, b);
         if (compared > 0)
-            return CP.gt;
+            return types_1.CP.gt;
         else if (compared < 0)
-            return CP.lt;
+            return types_1.CP.lt;
         else
-            return CP.eq;
+            return types_1.CP.eq;
     }
 }
+exports.BST = BST;

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

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./binary-tree"), exports);
+__exportStar(require("./bst"), exports);
+__exportStar(require("./binary-indexed-tree"), exports);
+__exportStar(require("./segment-tree"), exports);
+__exportStar(require("./avl-tree"), exports);
+__exportStar(require("./rb-tree"), exports);
+__exportStar(require("./tree-multiset"), exports);

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RBTree = exports.RBTreeNode = void 0;
+const types_1 = require("../../types");
+const bst_1 = require("./bst");
+class RBTreeNode extends bst_1.BSTNode {
+    constructor(key, val) {
+        super(key, val);
+        this._color = types_1.RBColor.RED;
+    }
+    _color;
+    get color() {
+        return this._color;
+    }
+    set color(value) {
+        this._color = value;
+    }
+}
+exports.RBTreeNode = RBTreeNode;
+class RBTree extends bst_1.BST {
+    constructor(options) {
+        super(options);
+    }
+    createNode(key, val) {
+        return new RBTreeNode(key, val);
+    }
+}
+exports.RBTree = RBTree;