data-structure-typed 0.8.18 → 1.12.9

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

@@ -1,9 +1,9 @@
-import { BinaryTree, BinaryTreeNode, BinaryTreeNodeId, BinaryTreeNodePropertyName, LoopType } from './binary-tree';
-export type BSTComparator = (a: BinaryTreeNodeId, b: BinaryTreeNodeId) => number;
-export type BSTDeletedResult<T> = {
-    deleted: BSTNode<T> | null;
-    needBalanced: BSTNode<T> | null;
-};
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+import type { BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTDeletedResult } from '../types';
+import { BinaryTree, BinaryTreeNode, LoopType } from './binary-tree';
 export declare enum CP {
     lt = -1,
     eq = 0,
@@ -13,13 +13,23 @@ export declare class BSTNode<T> extends BinaryTreeNode<T> {
     clone(): BSTNode<T>;
 }
 export declare class BST<T> extends BinaryTree<T> {
-    protected _comparator: BSTComparator;
-    protected _compare(a: BinaryTreeNodeId, b: BinaryTreeNodeId): CP;
     constructor(options?: {
         comparator?: BSTComparator;
         loopType?: LoopType;
     });
     createNode(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
+    /**
+     * The `put` function inserts a new node into a binary search tree, updating the count and value of an existing node if
+     * the ID matches, and returns the inserted node.
+     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node. It is used to
+     * determine the position of the node in the binary search tree.
+     * @param {T | null} val - The `val` parameter represents the value to be stored in the binary search tree node. It can
+     * be of type `T` (the generic type) or `null`.
+     * @param {number} [count=1] - The `count` parameter represents the number of times the value should be inserted into
+     * the binary search tree. By default, it is set to 1, meaning that if no count is specified, the value will be
+     * inserted once.
+     * @returns The method `put` returns a `BSTNode<T>` object or `null`.
+     */
     put(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
     get(nodeProperty: BinaryTreeNodeId | T, propertyName?: BinaryTreeNodePropertyName): BSTNode<T> | null;
     lastKey(): number;
@@ -29,4 +39,6 @@ export declare class BST<T> extends BinaryTree<T> {
     allGreaterNodesAdd(node: BSTNode<T>, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
     balance(): boolean;
     isAVLBalanced(): boolean;
+    protected _comparator: BSTComparator;
+    protected _compare(a: BinaryTreeNodeId, b: BinaryTreeNodeId): CP;
 }

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

@@ -1,46 +1,88 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BST = exports.BSTNode = exports.CP = void 0;
-const binary_tree_1 = require("./binary-tree");
+var binary_tree_1 = require("./binary-tree");
 var CP;
 (function (CP) {
     CP[CP["lt"] = -1] = "lt";
     CP[CP["eq"] = 0] = "eq";
     CP[CP["gt"] = 1] = "gt";
 })(CP = exports.CP || (exports.CP = {}));
-class BSTNode extends binary_tree_1.BinaryTreeNode {
-    clone() {
-        return new BSTNode(this.id, this.val, this.count);
+var BSTNode = /** @class */ (function (_super) {
+    __extends(BSTNode, _super);
+    function BSTNode() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-}
+    BSTNode.prototype.clone = function () {
+        return new BSTNode(this.id, this.val, this.count);
+    };
+    return BSTNode;
+}(binary_tree_1.BinaryTreeNode));
 exports.BSTNode = BSTNode;
-class BST extends binary_tree_1.BinaryTree {
-    _compare(a, b) {
-        const compared = this._comparator(a, b);
-        if (compared > 0)
-            return CP.gt;
-        else if (compared < 0)
-            return CP.lt;
-        else
-            return CP.eq;
-    }
-    constructor(options) {
-        super(options);
-        this._comparator = (a, b) => a - b;
+var BST = /** @class */ (function (_super) {
+    __extends(BST, _super);
+    function BST(options) {
+        var _this = _super.call(this, options) || this;
+        _this._comparator = function (a, b) { return a - b; };
         if (options !== undefined) {
-            const { comparator } = options;
+            var comparator = options.comparator;
             if (comparator !== undefined) {
-                this._comparator = comparator;
+                _this._comparator = comparator;
             }
         }
+        return _this;
     }
-    createNode(id, val, count) {
+    BST.prototype.createNode = function (id, val, count) {
         return val !== null ? new BSTNode(id, val, count) : null;
-    }
-    put(id, val, count = 1) {
+    };
+    /**
+     * The `put` function inserts a new node into a binary search tree, updating the count and value of an existing node if
+     * the ID matches, and returns the inserted node.
+     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node. It is used to
+     * determine the position of the node in the binary search tree.
+     * @param {T | null} val - The `val` parameter represents the value to be stored in the binary search tree node. It can
+     * be of type `T` (the generic type) or `null`.
+     * @param {number} [count=1] - The `count` parameter represents the number of times the value should be inserted into
+     * the binary search tree. By default, it is set to 1, meaning that if no count is specified, the value will be
+     * inserted once.
+     * @returns The method `put` returns a `BSTNode<T>` object or `null`.
+     */
+    BST.prototype.put = function (id, val, count) {
         var _a;
-        let inserted = null;
-        const newNode = this.createNode(id, val, count);
+        if (count === void 0) { count = 1; }
+        var inserted = null;
+        var newNode = this.createNode(id, val, count);
         if (this.root === null) {
             this.root = newNode;
             this.size++;
@@ -48,8 +90,8 @@ class BST extends binary_tree_1.BinaryTree {
             inserted = (this.root);
         }
         else {
-            let cur = this.root;
-            let traversing = true;
+            var cur = this.root;
+            var traversing = true;
             while (traversing) {
                 if (cur !== null && newNode !== null) {
                     if (this._compare(cur.id, id) === CP.eq) {
@@ -109,13 +151,13 @@ class BST extends binary_tree_1.BinaryTree {
             }
         }
         return inserted;
-    }
-    get(nodeProperty, propertyName) {
+    };
+    BST.prototype.get = function (nodeProperty, propertyName) {
         var _a;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         return (_a = this.getNodes(nodeProperty, propertyName, true)[0]) !== null && _a !== void 0 ? _a : null;
-    }
-    lastKey() {
+    };
+    BST.prototype.lastKey = function () {
         var _a, _b, _c, _d, _e, _f;
         if (this._compare(0, 1) === CP.lt)
             return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : 0;
@@ -123,16 +165,16 @@ class BST extends binary_tree_1.BinaryTree {
             return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : 0;
         else
             return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : 0;
-    }
-    remove(id, ignoreCount) {
-        const bstDeletedResult = [];
+    };
+    BST.prototype.remove = function (id, ignoreCount) {
+        var bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
-        const curr = this.get(id);
+        var curr = this.get(id);
         if (!curr)
             return bstDeletedResult;
-        const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
-        let needBalanced = null, orgCurrent = curr;
+        var parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
+        var needBalanced = null, orgCurrent = curr;
         if (curr.count > 1 && !ignoreCount) {
             curr.count--;
             this.count--;
@@ -156,9 +198,9 @@ class BST extends binary_tree_1.BinaryTree {
                 }
             }
             else {
-                const leftSubTreeMax = curr.left ? this.getRightMost(curr.left) : null;
+                var leftSubTreeMax = curr.left ? this.getRightMost(curr.left) : null;
                 if (leftSubTreeMax) {
-                    const parentOfLeftSubTreeMax = leftSubTreeMax.parent;
+                    var parentOfLeftSubTreeMax = leftSubTreeMax.parent;
                     orgCurrent = curr.swapLocation(leftSubTreeMax);
                     if (parentOfLeftSubTreeMax) {
                         if (parentOfLeftSubTreeMax.right === leftSubTreeMax)
@@ -172,37 +214,38 @@ class BST extends binary_tree_1.BinaryTree {
             this.size--;
             this.count -= curr.count;
         }
-        bstDeletedResult.push({ deleted: orgCurrent, needBalanced });
+        bstDeletedResult.push({ deleted: orgCurrent, needBalanced: needBalanced });
         return bstDeletedResult;
-    }
-    getNodes(nodeProperty, propertyName, onlyOne) {
+    };
+    BST.prototype.getNodes = function (nodeProperty, propertyName, onlyOne) {
+        var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         if (!this.root)
             return [];
-        const result = [];
+        var result = [];
         if (this._loopType === binary_tree_1.LoopType.recursive) {
-            const _traverse = (cur) => {
-                if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
+            var _traverse_1 = function (cur) {
+                if (_this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                     return;
                 if (!cur.left && !cur.right)
                     return;
                 if (propertyName === 'id') {
-                    if (this._compare(cur.id, nodeProperty) === CP.gt)
-                        cur.left && _traverse(cur.left);
-                    if (this._compare(cur.id, nodeProperty) === CP.lt)
-                        cur.right && _traverse(cur.right);
+                    if (_this._compare(cur.id, nodeProperty) === CP.gt)
+                        cur.left && _traverse_1(cur.left);
+                    if (_this._compare(cur.id, nodeProperty) === CP.lt)
+                        cur.right && _traverse_1(cur.right);
                 }
                 else {
-                    cur.left && _traverse(cur.left);
-                    cur.right && _traverse(cur.right);
+                    cur.left && _traverse_1(cur.left);
+                    cur.right && _traverse_1(cur.right);
                 }
             };
-            _traverse(this.root);
+            _traverse_1(this.root);
         }
         else {
-            const queue = [this.root];
+            var queue = [this.root];
             while (queue.length > 0) {
-                const cur = queue.shift();
+                var cur = queue.shift();
                 if (cur) {
                     if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                         return result;
@@ -220,14 +263,15 @@ class BST extends binary_tree_1.BinaryTree {
             }
         }
         return result;
-    }
+    };
     // --- start additional functions
-    lesserSum(id, propertyName) {
+    BST.prototype.lesserSum = function (id, propertyName) {
+        var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         if (!this.root)
             return 0;
-        const getSumByPropertyName = (cur) => {
-            let needSum;
+        var getSumByPropertyName = function (cur) {
+            var needSum;
             switch (propertyName) {
                 case 'id':
                     needSum = cur.id;
@@ -241,39 +285,39 @@ class BST extends binary_tree_1.BinaryTree {
             }
             return needSum;
         };
-        let sum = 0;
+        var sum = 0;
         if (this._loopType === binary_tree_1.LoopType.recursive) {
-            const _traverse = (cur) => {
-                const compared = this._compare(cur.id, id);
+            var _traverse_2 = function (cur) {
+                var compared = _this._compare(cur.id, id);
                 if (compared === CP.eq) {
                     if (cur.right)
-                        sum += this.subTreeSum(cur.right, propertyName);
+                        sum += _this.subTreeSum(cur.right, propertyName);
                     return;
                 }
                 else if (compared === CP.lt) {
                     if (cur.left)
-                        sum += this.subTreeSum(cur.left, propertyName);
+                        sum += _this.subTreeSum(cur.left, propertyName);
                     sum += getSumByPropertyName(cur);
                     if (cur.right)
-                        _traverse(cur.right);
+                        _traverse_2(cur.right);
                     else
                         return;
                 }
                 else {
                     if (cur.left)
-                        _traverse(cur.left);
+                        _traverse_2(cur.left);
                     else
                         return;
                 }
             };
-            _traverse(this.root);
+            _traverse_2(this.root);
         }
         else {
-            const queue = [this.root];
+            var queue = [this.root];
             while (queue.length > 0) {
-                const cur = queue.shift();
+                var cur = queue.shift();
                 if (cur) {
-                    const compared = this._compare(cur.id, id);
+                    var compared = this._compare(cur.id, id);
                     if (compared === CP.eq) {
                         if (cur.right)
                             sum += this.subTreeSum(cur.right, propertyName);
@@ -298,12 +342,13 @@ class BST extends binary_tree_1.BinaryTree {
             }
         }
         return sum;
-    }
-    allGreaterNodesAdd(node, delta, propertyName) {
+    };
+    BST.prototype.allGreaterNodesAdd = function (node, delta, propertyName) {
+        var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
         if (!this.root)
             return false;
-        const _sumByPropertyName = (cur) => {
+        var _sumByPropertyName = function (cur) {
             switch (propertyName) {
                 case 'id':
                     cur.id += delta;
@@ -317,25 +362,25 @@ class BST extends binary_tree_1.BinaryTree {
             }
         };
         if (this._loopType === binary_tree_1.LoopType.recursive) {
-            const _traverse = (cur) => {
-                const compared = this._compare(cur.id, node.id);
+            var _traverse_3 = function (cur) {
+                var compared = _this._compare(cur.id, node.id);
                 _sumByPropertyName(cur);
                 if (!cur.left && !cur.right)
                     return;
                 if (cur.left && compared === CP.gt)
-                    _traverse(cur.left);
+                    _traverse_3(cur.left);
                 else if (cur.right && compared === CP.gt)
-                    _traverse(cur.right);
+                    _traverse_3(cur.right);
             };
-            _traverse(this.root);
+            _traverse_3(this.root);
             return true;
         }
         else {
-            const queue = [this.root];
+            var queue = [this.root];
             while (queue.length > 0) {
-                const cur = queue.shift();
+                var cur = queue.shift();
                 if (cur) {
-                    const compared = this._compare(cur.id, node.id);
+                    var compared = this._compare(cur.id, node.id);
                     _sumByPropertyName(cur);
                     if (cur.left && compared === CP.gt)
                         queue.push(cur.left);
@@ -345,34 +390,35 @@ class BST extends binary_tree_1.BinaryTree {
             }
             return true;
         }
-    }
-    balance() {
-        const sorted = this.DFS('in', 'node'), n = sorted.length;
+    };
+    BST.prototype.balance = function () {
+        var _this = this;
+        var sorted = this.DFS('in', 'node'), n = sorted.length;
         this.clear();
         if (sorted.length < 1)
             return false;
         if (this._loopType === binary_tree_1.LoopType.recursive) {
-            const buildBalanceBST = (l, r) => {
+            var buildBalanceBST_1 = function (l, r) {
                 if (l > r)
                     return;
-                const m = l + Math.floor((r - l) / 2);
-                const midNode = sorted[m];
-                this.put(midNode.id, midNode.val, midNode.count);
-                buildBalanceBST(l, m - 1);
-                buildBalanceBST(m + 1, r);
+                var m = l + Math.floor((r - l) / 2);
+                var midNode = sorted[m];
+                _this.put(midNode.id, midNode.val, midNode.count);
+                buildBalanceBST_1(l, m - 1);
+                buildBalanceBST_1(m + 1, r);
             };
-            buildBalanceBST(0, n - 1);
+            buildBalanceBST_1(0, n - 1);
             return true;
         }
         else {
-            const stack = [[0, n - 1]];
+            var stack = [[0, n - 1]];
             while (stack.length > 0) {
-                const popped = stack.pop();
+                var popped = stack.pop();
                 if (popped) {
-                    const [l, r] = popped;
+                    var _a = __read(popped, 2), l = _a[0], r = _a[1];
                     if (l <= r) {
-                        const m = l + Math.floor((r - l) / 2);
-                        const midNode = sorted[m];
+                        var m = l + Math.floor((r - l) / 2);
+                        var midNode = sorted[m];
                         this.put(midNode.id, midNode.val, midNode.count);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -381,26 +427,27 @@ class BST extends binary_tree_1.BinaryTree {
             }
             return true;
         }
-    }
-    isAVLBalanced() {
+    };
+    BST.prototype.isAVLBalanced = function () {
         var _a, _b;
         if (!this.root)
             return true;
-        let balanced = true;
+        var balanced = true;
         if (this._loopType === binary_tree_1.LoopType.recursive) {
-            const _height = (cur) => {
+            var _height_1 = function (cur) {
                 if (!cur)
                     return 0;
-                const leftHeight = _height(cur.left), rightHeight = _height(cur.right);
+                var leftHeight = _height_1(cur.left), rightHeight = _height_1(cur.right);
                 if (Math.abs(leftHeight - rightHeight) > 1)
                     balanced = false;
                 return Math.max(leftHeight, rightHeight) + 1;
             };
-            _height(this.root);
+            _height_1(this.root);
         }
         else {
-            const stack = [];
-            let node = this.root, last = null, depths = new Map();
+            var stack = [];
+            var node = this.root, last = null;
+            var depths = new Map();
             while (stack.length > 0 || node) {
                 if (node) {
                     stack.push(node);
@@ -411,8 +458,8 @@ class BST extends binary_tree_1.BinaryTree {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            let left = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
-                            let right = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
+                            var left = node.left ? (_a = depths.get(node.left)) !== null && _a !== void 0 ? _a : -1 : -1;
+                            var right = node.right ? (_b = depths.get(node.right)) !== null && _b !== void 0 ? _b : -1 : -1;
                             if (Math.abs(left - right) > 1)
                                 return false;
                             depths.set(node, 1 + Math.max(left, right));
@@ -426,6 +473,16 @@ class BST extends binary_tree_1.BinaryTree {
             }
         }
         return balanced;
-    }
-}
+    };
+    BST.prototype._compare = function (a, b) {
+        var compared = this._comparator(a, b);
+        if (compared > 0)
+            return CP.gt;
+        else if (compared < 0)
+            return CP.lt;
+        else
+            return CP.eq;
+    };
+    return BST;
+}(binary_tree_1.BinaryTree));
 exports.BST = BST;

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RBTree = void 0;
-class RBTree {
-}
+var RBTree = /** @class */ (function () {
+    function RBTree() {
+    }
+    return RBTree;
+}());
 exports.RBTree = RBTree;

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

@@ -1,5 +1,10 @@
-export type SegmentTreeNodeVal = number;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+import type { SegmentTreeNodeVal } from '../types';
 export declare class SegmentTreeNode {
+    constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null);
     protected _start: number;
     get start(): number;
     set start(v: number);
@@ -18,15 +23,14 @@ export declare class SegmentTreeNode {
     protected _right: SegmentTreeNode | null;
     get right(): SegmentTreeNode | null;
     set right(v: SegmentTreeNode | null);
-    constructor(start: number, end: number, sum: number, val?: SegmentTreeNodeVal | null);
 }
 export declare class SegmentTree {
     protected _values: number[];
     protected _start: number;
     protected _end: number;
+    constructor(values: number[], start?: number, end?: number);
     protected _root: SegmentTreeNode | null;
     get root(): SegmentTreeNode | null;
-    constructor(values: number[], start?: number, end?: number);
     build(start: number, end: number): SegmentTreeNode;
     updateNode(index: number, sum: number, val?: SegmentTreeNodeVal): void;
     querySumByRange(indexA: number, indexB: number): number;