data-structure-typed 1.38.1 → 1.38.3

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;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * data-structure-typed
  *
@@ -5,49 +6,51 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export class SegmentTreeNode {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentTree = exports.SegmentTreeNode = void 0;
+class SegmentTreeNode {
     constructor(start, end, sum, val) {
-        this._start = 0;
-        this._end = 0;
-        this._val = null;
-        this._sum = 0;
-        this._left = null;
-        this._right = null;
         this._start = start;
         this._end = end;
         this._sum = sum;
         this._val = val || null;
     }
+    _start = 0;
     get start() {
         return this._start;
     }
     set start(v) {
         this._start = v;
     }
+    _end = 0;
     get end() {
         return this._end;
     }
     set end(v) {
         this._end = v;
     }
+    _val = null;
     get val() {
         return this._val;
     }
     set val(v) {
         this._val = v;
     }
+    _sum = 0;
     get sum() {
         return this._sum;
     }
     set sum(v) {
         this._sum = v;
     }
+    _left = null;
     get left() {
         return this._left;
     }
     set left(v) {
         this._left = v;
     }
+    _right = null;
     get right() {
         return this._right;
     }
@@ -55,7 +58,8 @@ export class SegmentTreeNode {
         this._right = v;
     }
 }
-export class SegmentTree {
+exports.SegmentTreeNode = SegmentTreeNode;
+class SegmentTree {
     /**
      * The constructor initializes the values, start, end, and root properties of an object.
      * @param {number[]} values - An array of numbers that will be used to build a binary search tree.
@@ -66,8 +70,6 @@ export class SegmentTree {
      * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
      */
     constructor(values, start, end) {
-        this._values = [];
-        this._start = 0;
         start = start || 0;
         end = end || values.length - 1;
         this._values = values;
@@ -81,15 +83,19 @@ export class SegmentTree {
             this._values = [];
         }
     }
+    _values = [];
     get values() {
         return this._values;
     }
+    _start = 0;
     get start() {
         return this._start;
     }
+    _end;
     get end() {
         return this._end;
     }
+    _root;
     get root() {
         return this._root;
     }
@@ -221,3 +227,4 @@ export class SegmentTree {
         this._root = v;
     }
 }
+exports.SegmentTree = SegmentTree;

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

@@ -1,6 +1,10 @@
-import { CP, FamilyPosition, IterationType } from '../../types';
-import { AVLTree, AVLTreeNode } from './avl-tree';
-export class TreeMultisetNode extends AVLTreeNode {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeMultiset = exports.TreeMultisetNode = void 0;
+const types_1 = require("../../types");
+const avl_tree_1 = require("./avl-tree");
+class TreeMultisetNode extends avl_tree_1.AVLTreeNode {
+    count;
     /**
      * The constructor function initializes a BinaryTreeNode object with a key, value, and count.
      * @param {BinaryTreeNodeKey} key - The `key` parameter is of type `BinaryTreeNodeKey` and represents the unique identifier
@@ -16,10 +20,11 @@ export class TreeMultisetNode extends AVLTreeNode {
         this.count = count;
     }
 }
+exports.TreeMultisetNode = TreeMultisetNode;
 /**
  * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
  */
-export class TreeMultiset extends AVLTree {
+class TreeMultiset extends avl_tree_1.AVLTree {
     /**
      * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
      * merge duplicated values.
@@ -28,8 +33,8 @@ export class TreeMultiset extends AVLTree {
      */
     constructor(options) {
         super(options);
-        this._count = 0;
     }
+    _count = 0;
     get count() {
         return this._count;
     }
@@ -81,14 +86,14 @@ export class TreeMultiset extends AVLTree {
             while (traversing) {
                 if (cur) {
                     if (newNode) {
-                        if (this._compare(cur.key, newNode.key) === CP.eq) {
+                        if (this._compare(cur.key, newNode.key) === types_1.CP.eq) {
                             cur.val = newNode.val;
                             cur.count += newNode.count;
                             this._setCount(this.count + newNode.count);
                             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) {
                                 //Add to the left of the current node
@@ -104,7 +109,7 @@ export class TreeMultiset extends AVLTree {
                                     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) {
                                 //Add to the right of the current node
@@ -190,7 +195,7 @@ export class TreeMultiset extends AVLTree {
                 inserted.push(this.add(NaN, null, 0));
                 continue;
             }
-            inserted.push(this.add(keyOrNode, data === null || data === void 0 ? void 0 : data[i], 1));
+            inserted.push(this.add(keyOrNode, data?.[i], 1));
         }
         return inserted;
     }
@@ -207,7 +212,7 @@ export class TreeMultiset extends AVLTree {
         if (sorted.length < 1)
             return false;
         this.clear();
-        if (iterationType === IterationType.RECURSIVE) {
+        if (iterationType === types_1.IterationType.RECURSIVE) {
             const buildBalanceBST = (l, r) => {
                 if (l > r)
                     return;
@@ -257,7 +262,7 @@ export class TreeMultiset extends AVLTree {
         const curr = this.get(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.count > 1 && !ignoreCount) {
             curr.count--;
@@ -271,10 +276,10 @@ export class TreeMultiset extends AVLTree {
                 }
                 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;
@@ -344,3 +349,4 @@ export class TreeMultiset extends AVLTree {
         this._count = v;
     }
 }
+exports.TreeMultiset = TreeMultiset;