data-structure-typed 1.12.11 → 1.12.21

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

@@ -52,6 +52,10 @@ var BSTNode = /** @class */ (function (_super) {
 exports.BSTNode = BSTNode;
 var BST = /** @class */ (function (_super) {
     __extends(BST, _super);
+    /**
+     * The constructor function accepts an optional options object and sets the comparator property if provided.
+     * @param [options] - An optional object that can contain the following properties:
+     */
     function BST(options) {
         var _this = _super.call(this, options) || this;
         _this._comparator = function (a, b) { return a - b; };
@@ -67,7 +71,7 @@ var BST = /** @class */ (function (_super) {
         return val !== null ? new BSTNode(id, val, count) : null;
     };
     /**
-     * The `put` function inserts a new node into a binary search tree, updating the count and value of an existing node if
+     * The `add` 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.
@@ -76,9 +80,9 @@ var BST = /** @class */ (function (_super) {
      * @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`.
+     * @returns The method `add` returns a `BSTNode<T>` object or `null`.
      */
-    BST.prototype.put = function (id, val, count) {
+    BST.prototype.add = function (id, val, count) {
         var _a;
         if (count === void 0) { count = 1; }
         var inserted = null;
@@ -152,11 +156,28 @@ var BST = /** @class */ (function (_super) {
         }
         return inserted;
     };
+    /**
+     * The `get` function returns the first node in a binary search tree that matches the given property value or name.
+     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `T`. It represents the value of the property that you want to search for in the binary search tree.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * specifies the property name to use for searching the binary search tree nodes. If not provided, it defaults to
+     * `'id'`.
+     * @returns The method is returning a BSTNode<T> object or null.
+     */
     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;
     };
+    /**
+     * The function returns the id of the rightmost node if the comparison between two values is less than, the id of the
+     * leftmost node if the comparison is greater than, and the id of the rightmost node otherwise.
+     * @returns The function `lastKey()` returns the ID of the rightmost node in a binary tree. If the comparison between
+     * the first two elements in the tree is less than, it returns the ID of the rightmost node. If the comparison is
+     * greater than, it returns the ID of the leftmost node. Otherwise, it also returns the ID of the rightmost node. If
+     * there are no nodes in
+     */
     BST.prototype.lastKey = function () {
         var _a, _b, _c, _d, _e, _f;
         if (this._compare(0, 1) === CP.lt)
@@ -166,6 +187,16 @@ var BST = /** @class */ (function (_super) {
         else
             return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : 0;
     };
+    /**
+     * The `remove` function in this TypeScript code removes a node from a binary search tree and returns information about
+     * the deleted node and any nodes that need to be balanced.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that needs to be removed
+     * from the binary search tree.
+     * @param {boolean} [ignoreCount] - A boolean flag indicating whether to ignore the count of the node being removed. If
+     * set to true, the count of the node will not be considered and the node will be removed regardless of its count. If
+     * set to false or not provided, the count of the node will be taken into account and the
+     * @returns an array of `BSTDeletedResult<T>` objects.
+     */
     BST.prototype.remove = function (id, ignoreCount) {
         var bstDeletedResult = [];
         if (!this.root)
@@ -217,6 +248,19 @@ var BST = /** @class */ (function (_super) {
         bstDeletedResult.push({ deleted: orgCurrent, needBalanced: needBalanced });
         return bstDeletedResult;
     };
+    /**
+     * The function `getNodes` returns an array of binary search tree nodes that match a given property value, with the
+     * option to specify the property name and whether to return only one node.
+     * @param {BinaryTreeNodeId | T} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * generic type `T`. It represents the property value that you want to search for in the binary search tree.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * specifies the property of the nodes to compare with the `nodeProperty` parameter. If not provided, it defaults to
+     * `'id'`.
+     * @param {boolean} [onlyOne] - A boolean value indicating whether to return only one node that matches the given
+     * nodeProperty. If set to true, the function will stop traversing the tree and return the first matching node. If set
+     * to false or not provided, the function will return all nodes that match the given nodeProperty.
+     * @returns an array of BSTNode<T> objects.
+     */
     BST.prototype.getNodes = function (nodeProperty, propertyName, onlyOne) {
         var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
@@ -265,6 +309,16 @@ var BST = /** @class */ (function (_super) {
         return result;
     };
     // --- start additional functions
+    /**
+     * The `lesserSum` function calculates the sum of a specified property in all nodes with an ID less than a given ID in
+     * a binary search tree.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node for which you want to
+     * calculate the lesser sum.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
+     * specifies the property of the binary tree node to use for calculating the sum. If not provided, it defaults to 'id'.
+     * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in the
+     * binary search tree that have a property value lesser than the given `id`.
+     */
     BST.prototype.lesserSum = function (id, propertyName) {
         var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
@@ -343,6 +397,18 @@ var BST = /** @class */ (function (_super) {
         }
         return sum;
     };
+    /**
+     * The function `allGreaterNodesAdd` updates the value of a specified property for all nodes in a binary search tree
+     * that have a greater value than a given node.
+     * @param node - The `node` parameter is of type `BSTNode<T>`, which represents a node in a binary search tree. It
+     * contains properties such as `id` and `count`.
+     * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
+     * each node should be increased.
+     * @param {BinaryTreeNodePropertyName} [propertyName] - propertyName is an optional parameter that specifies the
+     * property of the BSTNode to be modified. It can be either 'id' or 'count'. If propertyName is not provided, it
+     * defaults to 'id'.
+     * @returns a boolean value.
+     */
     BST.prototype.allGreaterNodesAdd = function (node, delta, propertyName) {
         var _this = this;
         propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
@@ -391,6 +457,11 @@ var BST = /** @class */ (function (_super) {
             return true;
         }
     };
+    /**
+     * The `balance` function takes a sorted array of nodes and builds a balanced binary search tree using either a
+     * recursive or iterative approach.
+     * @returns The `balance()` function returns a boolean value.
+     */
     BST.prototype.balance = function () {
         var _this = this;
         var sorted = this.DFS('in', 'node'), n = sorted.length;
@@ -403,7 +474,7 @@ var BST = /** @class */ (function (_super) {
                     return;
                 var m = l + Math.floor((r - l) / 2);
                 var midNode = sorted[m];
-                _this.put(midNode.id, midNode.val, midNode.count);
+                _this.add(midNode.id, midNode.val, midNode.count);
                 buildBalanceBST_1(l, m - 1);
                 buildBalanceBST_1(m + 1, r);
             };
@@ -419,7 +490,7 @@ var BST = /** @class */ (function (_super) {
                     if (l <= r) {
                         var m = l + Math.floor((r - l) / 2);
                         var midNode = sorted[m];
-                        this.put(midNode.id, midNode.val, midNode.count);
+                        this.add(midNode.id, midNode.val, midNode.count);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -428,6 +499,11 @@ var BST = /** @class */ (function (_super) {
             return true;
         }
     };
+    /**
+     * The function `isAVLBalanced` checks if a binary search tree is balanced according to the AVL tree property.
+     * @returns The function `isAVLBalanced()` returns a boolean value. It returns `true` if the binary search tree (BST)
+     * is balanced according to the AVL tree property, and `false` otherwise.
+     */
     BST.prototype.isAVLBalanced = function () {
         var _a, _b;
         if (!this.root)
@@ -474,6 +550,14 @@ var BST = /** @class */ (function (_super) {
         }
         return balanced;
     };
+    /**
+     * The function compares two binary tree node IDs using a comparator function and returns whether the first ID is
+     * greater than, less than, or equal to the second ID.
+     * @param {BinaryTreeNodeId} a - a is a BinaryTreeNodeId, which represents the identifier of a binary tree node.
+     * @param {BinaryTreeNodeId} b - The parameter "b" in the above code refers to a BinaryTreeNodeId.
+     * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater than), CP.lt (less
+     * than), or CP.eq (equal).
+     */
     BST.prototype._compare = function (a, b) {
         var compared = this._comparator(a, b);
         if (compared > 0)

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

@@ -1,6 +1,9 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import type { SegmentTreeNodeVal } from '../types';
 export declare class SegmentTreeNode {
@@ -28,10 +31,46 @@ export declare class SegmentTree {
     protected _values: number[];
     protected _start: number;
     protected _end: number;
+    /**
+     * 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.
+     * @param {number} [start] - The `start` parameter is the index of the first element in the `values` array that should
+     * be included in the range. If no value is provided for `start`, it defaults to 0, which means the range starts from
+     * the beginning of the array.
+     * @param {number} [end] - The "end" parameter is the index of the last element in the "values" array that should be
+     * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
+     */
     constructor(values: number[], start?: number, end?: number);
     protected _root: SegmentTreeNode | null;
     get root(): SegmentTreeNode | null;
+    /**
+     * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes
+     * for each segment.
+     * @param {number} start - The `start` parameter represents the starting index of the segment or range for which we are
+     * building the segment tree.
+     * @param {number} end - The `end` parameter represents the ending index of the segment or range for which we are
+     * building the segment tree.
+     * @returns a SegmentTreeNode object.
+     */
     build(start: number, end: number): SegmentTreeNode;
+    /**
+     * The function updates the value of a node in a segment tree and recalculates the sum of its children if they exist.
+     * @param {number} index - The index parameter represents the index of the node in the segment tree that needs to be
+     * updated.
+     * @param {number} sum - The `sum` parameter represents the new value that should be assigned to the `sum` property of
+     * the `SegmentTreeNode` at the specified `index`.
+     * @param {SegmentTreeNodeVal} [val] - The `val` parameter is an optional value that can be assigned to the `val`
+     * property of the `SegmentTreeNode` object. It is not currently used in the code, but you can uncomment the line `//
+     * cur.val = val;` and pass a value for `val` in the
+     * @returns The function does not return anything.
+     */
     updateNode(index: number, sum: number, val?: SegmentTreeNodeVal): void;
+    /**
+     * The function `querySumByRange` calculates the sum of values within a given range in a segment tree.
+     * @param {number} indexA - The starting index of the range for which you want to calculate the sum.
+     * @param {number} indexB - The parameter `indexB` represents the ending index of the range for which you want to
+     * calculate the sum.
+     * @returns The function `querySumByRange` returns a number.
+     */
     querySumByRange(indexA: number, indexB: number): number;
 }

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

@@ -1,7 +1,10 @@
 "use strict";
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SegmentTree = exports.SegmentTreeNode = void 0;
@@ -82,6 +85,15 @@ var SegmentTreeNode = /** @class */ (function () {
 }());
 exports.SegmentTreeNode = SegmentTreeNode;
 var SegmentTree = /** @class */ (function () {
+    /**
+     * 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.
+     * @param {number} [start] - The `start` parameter is the index of the first element in the `values` array that should
+     * be included in the range. If no value is provided for `start`, it defaults to 0, which means the range starts from
+     * the beginning of the array.
+     * @param {number} [end] - The "end" parameter is the index of the last element in the "values" array that should be
+     * included in the range. If not provided, it defaults to the index of the last element in the "values" array.
+     */
     function SegmentTree(values, start, end) {
         this._values = [];
         this._start = 0;
@@ -99,6 +111,15 @@ var SegmentTree = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    /**
+     * The function builds a segment tree by recursively dividing the given range into smaller segments and creating nodes
+     * for each segment.
+     * @param {number} start - The `start` parameter represents the starting index of the segment or range for which we are
+     * building the segment tree.
+     * @param {number} end - The `end` parameter represents the ending index of the segment or range for which we are
+     * building the segment tree.
+     * @returns a SegmentTreeNode object.
+     */
     SegmentTree.prototype.build = function (start, end) {
         if (start === end) {
             return new SegmentTreeNode(start, end, this._values[start]);
@@ -111,6 +132,17 @@ var SegmentTree = /** @class */ (function () {
         cur.right = right;
         return cur;
     };
+    /**
+     * The function updates the value of a node in a segment tree and recalculates the sum of its children if they exist.
+     * @param {number} index - The index parameter represents the index of the node in the segment tree that needs to be
+     * updated.
+     * @param {number} sum - The `sum` parameter represents the new value that should be assigned to the `sum` property of
+     * the `SegmentTreeNode` at the specified `index`.
+     * @param {SegmentTreeNodeVal} [val] - The `val` parameter is an optional value that can be assigned to the `val`
+     * property of the `SegmentTreeNode` object. It is not currently used in the code, but you can uncomment the line `//
+     * cur.val = val;` and pass a value for `val` in the
+     * @returns The function does not return anything.
+     */
     SegmentTree.prototype.updateNode = function (index, sum, val) {
         var root = this.root || null;
         if (!root) {
@@ -139,6 +171,13 @@ var SegmentTree = /** @class */ (function () {
         };
         dfs(root, index, sum);
     };
+    /**
+     * The function `querySumByRange` calculates the sum of values within a given range in a segment tree.
+     * @param {number} indexA - The starting index of the range for which you want to calculate the sum.
+     * @param {number} indexB - The parameter `indexB` represents the ending index of the range for which you want to
+     * calculate the sum.
+     * @returns The function `querySumByRange` returns a number.
+     */
     SegmentTree.prototype.querySumByRange = function (indexA, indexB) {
         var root = this.root || null;
         if (!root) {

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

@@ -1,11 +1,42 @@
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 import { BST, BSTNode } from './bst';
 import type { BinaryTreeNodeId, TreeMultiSetDeletedResult } from '../types';
 export declare class TreeMultiSet<T> extends BST<T> {
+    /**
+     * The function creates a new BSTNode with the given id, value, and count.
+     * @param {BinaryTreeNodeId} id - The id parameter is the unique identifier for the binary tree node. It is used to
+     * distinguish one node from another in the tree.
+     * @param {T} val - The `val` parameter represents the value that will be stored in the binary search tree node.
+     * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
+     * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
+     * @returns A new instance of the BSTNode class with the specified id, value, and count (if provided).
+     */
     createNode(id: BinaryTreeNodeId, val: T, count?: number): BSTNode<T>;
-    put(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
+    /**
+     * The function overrides the add method of the BinarySearchTree class in TypeScript.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to add.
+     * @param {T | null} val - The `val` parameter represents the value that you want to add to the binary search tree. It
+     * can be of type `T` (the generic type) or `null`.
+     * @param {number} [count] - The `count` parameter is an optional parameter of type `number`. It represents the number
+     * of times the value should be added to the binary search tree. If not provided, the default value is `undefined`.
+     * @returns The `add` method is returning a `BSTNode<T>` object or `null`.
+     */
+    add(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null;
+    /**
+     * The function overrides the remove method of the superclass and returns the result of calling the superclass's remove
+     * method.
+     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
+     * removed from the tree.
+     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean value that
+     * determines whether to update the left sum of all nodes in the tree after removing a node. If `isUpdateAllLeftSum` is
+     * set to `true`, the left sum of all nodes will be recalculated. If it
+     * @returns The method is returning an array of TreeMultiSetDeletedResult objects.
+     */
     remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): TreeMultiSetDeletedResult<T>[];
 }

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

@@ -17,8 +17,11 @@ var __extends = (this && this.__extends) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TreeMultiSet = void 0;
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var bst_1 = require("./bst");
 var TreeMultiSet = /** @class */ (function (_super) {
@@ -26,12 +29,40 @@ var TreeMultiSet = /** @class */ (function (_super) {
     function TreeMultiSet() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * The function creates a new BSTNode with the given id, value, and count.
+     * @param {BinaryTreeNodeId} id - The id parameter is the unique identifier for the binary tree node. It is used to
+     * distinguish one node from another in the tree.
+     * @param {T} val - The `val` parameter represents the value that will be stored in the binary search tree node.
+     * @param {number} [count] - The "count" parameter is an optional parameter of type number. It represents the number of
+     * occurrences of the value in the binary search tree node. If not provided, the count will default to 1.
+     * @returns A new instance of the BSTNode class with the specified id, value, and count (if provided).
+     */
     TreeMultiSet.prototype.createNode = function (id, val, count) {
         return new bst_1.BSTNode(id, val, count);
     };
-    TreeMultiSet.prototype.put = function (id, val, count) {
-        return _super.prototype.put.call(this, id, val, count);
+    /**
+     * The function overrides the add method of the BinarySearchTree class in TypeScript.
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that you want to add.
+     * @param {T | null} val - The `val` parameter represents the value that you want to add to the binary search tree. It
+     * can be of type `T` (the generic type) or `null`.
+     * @param {number} [count] - The `count` parameter is an optional parameter of type `number`. It represents the number
+     * of times the value should be added to the binary search tree. If not provided, the default value is `undefined`.
+     * @returns The `add` method is returning a `BSTNode<T>` object or `null`.
+     */
+    TreeMultiSet.prototype.add = function (id, val, count) {
+        return _super.prototype.add.call(this, id, val, count);
     };
+    /**
+     * The function overrides the remove method of the superclass and returns the result of calling the superclass's remove
+     * method.
+     * @param {BinaryTreeNodeId} id - The `id` parameter represents the identifier of the binary tree node that needs to be
+     * removed from the tree.
+     * @param {boolean} [isUpdateAllLeftSum] - The `isUpdateAllLeftSum` parameter is an optional boolean value that
+     * determines whether to update the left sum of all nodes in the tree after removing a node. If `isUpdateAllLeftSum` is
+     * set to `true`, the left sum of all nodes will be recalculated. If it
+     * @returns The method is returning an array of TreeMultiSetDeletedResult objects.
+     */
     TreeMultiSet.prototype.remove = function (id, isUpdateAllLeftSum) {
         return _super.prototype.remove.call(this, id, isUpdateAllLeftSum);
     };

package/dist/data-structures/graph/abstract-graph.d.ts

@@ -7,6 +7,11 @@ export declare class AbstractVertex {
 }
 export declare abstract class AbstractEdge {
     static DEFAULT_EDGE_WEIGHT: number;
+    /**
+     * The function is a protected constructor that initializes the weight and generates a unique hash code for an edge.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. If
+     * no weight is provided, it will default to the value of `AbstractEdge.DEFAULT_EDGE_WEIGHT`.
+     */
     protected constructor(weight?: number);
     private _weight;
     get weight(): number;

package/dist/data-structures/graph/abstract-graph.js

@@ -38,8 +38,11 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractGraph = exports.AbstractEdge = exports.AbstractVertex = void 0;
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var utils_1 = require("../../utils");
 var priority_queue_1 = require("../priority-queue");
@@ -61,6 +64,11 @@ var AbstractVertex = /** @class */ (function () {
 }());
 exports.AbstractVertex = AbstractVertex;
 var AbstractEdge = /** @class */ (function () {
+    /**
+     * The function is a protected constructor that initializes the weight and generates a unique hash code for an edge.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge. If
+     * no weight is provided, it will default to the value of `AbstractEdge.DEFAULT_EDGE_WEIGHT`.
+     */
     function AbstractEdge(weight) {
         if (weight === undefined)
             weight = AbstractEdge.DEFAULT_EDGE_WEIGHT;
@@ -660,7 +668,7 @@ var AbstractGraph = /** @class */ (function () {
             finally { if (e_11) throw e_11.error; }
         }
         var heap = new priority_queue_1.PriorityQueue({ comparator: function (a, b) { return a.id - b.id; } });
-        heap.offer({ id: 0, val: srcVertex });
+        heap.add({ id: 0, val: srcVertex });
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);
         var getPaths = function (minV) {
@@ -717,7 +725,7 @@ var AbstractGraph = /** @class */ (function () {
                                     var distSrcToNeighbor = distMap.get(neighbor);
                                     if (distSrcToNeighbor) {
                                         if (dist + weight < distSrcToNeighbor) {
-                                            heap.offer({ id: dist + weight, val: neighbor });
+                                            heap.add({ id: dist + weight, val: neighbor });
                                             preMap.set(neighbor, cur);
                                             distMap.set(neighbor, dist + weight);
                                         }

package/dist/data-structures/graph/directed-graph.d.ts

@@ -1,9 +1,23 @@
 import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 import type { IDirectedGraph, VertexId } from '../types';
 export declare class DirectedVertex extends AbstractVertex {
+    /**
+     * The constructor function initializes an object with a given id.
+     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is used to uniquely identify the
+     * vertex within a graph or network.
+     */
     constructor(id: VertexId);
 }
 export declare class DirectedEdge extends AbstractEdge {
+    /**
+     * The constructor function initializes the source and destination vertices of an edge, with an optional weight.
+     * @param {VertexId} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
+     * a graph.
+     * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex. It represents the vertex
+     * to which an edge is directed.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge
+     * between two vertices.
+     */
     constructor(src: VertexId, dest: VertexId, weight?: number);
     private _src;
     get src(): VertexId;
@@ -123,10 +137,10 @@ export declare class DirectedGraph<V extends DirectedVertex, E extends DirectedE
     /**
      * when stored with adjacency list time: O(V+E)
      * when stored with adjacency matrix time: O(V^2)
-     * The `topologicalSort` function performs a topological sort on a directed graph and returns the sorted vertices in
-     * reverse order, or null if the graph contains a cycle.
-     * @returns The function `topologicalSort()` returns an array of vertices in topological order if there is no cycle in
-     * the graph. If there is a cycle in the graph, it returns `null`.
+     * The `topologicalSort` function performs a topological sort on a graph and returns the sorted vertices in reverse
+     * order, or null if the graph contains a cycle.
+     * @returns The `topologicalSort()` function returns an array of vertices (`V[]`) in topological order if there is no
+     * cycle in the graph. If there is a cycle, it returns `null`.
      */
     topologicalSort(): V[] | null;
     /**--- end find cycles --- */

package/dist/data-structures/graph/directed-graph.js

@@ -53,13 +53,21 @@ var __values = (this && this.__values) || function(o) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DirectedGraph = exports.DirectedEdge = exports.DirectedVertex = void 0;
 /**
- * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
  */
 var utils_1 = require("../../utils");
 var abstract_graph_1 = require("./abstract-graph");
 var DirectedVertex = /** @class */ (function (_super) {
     __extends(DirectedVertex, _super);
+    /**
+     * The constructor function initializes an object with a given id.
+     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is used to uniquely identify the
+     * vertex within a graph or network.
+     */
     function DirectedVertex(id) {
         return _super.call(this, id) || this;
     }
@@ -68,6 +76,15 @@ var DirectedVertex = /** @class */ (function (_super) {
 exports.DirectedVertex = DirectedVertex;
 var DirectedEdge = /** @class */ (function (_super) {
     __extends(DirectedEdge, _super);
+    /**
+     * The constructor function initializes the source and destination vertices of an edge, with an optional weight.
+     * @param {VertexId} src - The `src` parameter is the source vertex ID. It represents the starting point of an edge in
+     * a graph.
+     * @param {VertexId} dest - The `dest` parameter is the identifier of the destination vertex. It represents the vertex
+     * to which an edge is directed.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge
+     * between two vertices.
+     */
     function DirectedEdge(src, dest, weight) {
         var _this = _super.call(this, weight) || this;
         _this._src = src;
@@ -342,43 +359,14 @@ var DirectedGraph = /** @class */ (function (_super) {
     /**
      * when stored with adjacency list time: O(V+E)
      * when stored with adjacency matrix time: O(V^2)
-     * The `topologicalSort` function performs a topological sort on a directed graph and returns the sorted vertices in
-     * reverse order, or null if the graph contains a cycle.
-     * @returns The function `topologicalSort()` returns an array of vertices in topological order if there is no cycle in
-     * the graph. If there is a cycle in the graph, it returns `null`.
+     * The `topologicalSort` function performs a topological sort on a graph and returns the sorted vertices in reverse
+     * order, or null if the graph contains a cycle.
+     * @returns The `topologicalSort()` function returns an array of vertices (`V[]`) in topological order if there is no
+     * cycle in the graph. If there is a cycle, it returns `null`.
      */
     DirectedGraph.prototype.topologicalSort = function () {
         var e_2, _a, e_3, _b;
         var _this = this;
-        // vector<vector<int>> g;
-        // vector<int> color;
-        // int last;
-        // bool hasCycle;
-        //
-        // bool topo_sort() {
-        //     int n = g.size();
-        //     vector<int> degree(n, 0);
-        //     queue<int> q;
-        //     for (int i = 0; i < n; i++) {
-        //         degree[i] = g[i].size();
-        //         if (degree[i] <= 1) {
-        //             q.push(i);
-        //         }
-        //     }
-        //     int cnt = 0;
-        //     while (!q.empty()) {
-        //         cnt++;
-        //         int root = q.front();
-        //         q.pop();
-        //         for (auto child : g[root]) {
-        //             degree[child]--;
-        //             if (degree[child] == 1) {
-        //                 q.push(child);
-        //             }
-        //         }
-        //     }
-        //     return (cnt != n);
-        // }
         // When judging whether there is a cycle in the undirected graph, all nodes with degree of **<= 1** are enqueued
         // When judging whether there is a cycle in the directed graph, all nodes with **in degree = 0** are enqueued
         var statusMap = new Map();
@@ -438,9 +426,8 @@ var DirectedGraph = /** @class */ (function (_super) {
             }
             finally { if (e_3) throw e_3.error; }
         }
-        if (hasCycle) {
+        if (hasCycle)
             return null;
-        }
         return sorted.reverse();
     };
     /**--- end find cycles --- */

package/dist/data-structures/graph/undirected-graph.d.ts

@@ -1,9 +1,22 @@
 import { AbstractEdge, AbstractGraph, AbstractVertex } from './abstract-graph';
 import type { VertexId } from '../types';
 export declare class UndirectedVertex extends AbstractVertex {
+    /**
+     * The constructor function initializes an object with a given id.
+     * @param {VertexId} id - The `id` parameter is the identifier for the vertex. It is used to uniquely identify the
+     * vertex within a graph or network.
+     */
     constructor(id: VertexId);
 }
 export declare class UndirectedEdge extends AbstractEdge {
+    /**
+     * The constructor function initializes an instance of a class with two vertex IDs and an optional weight.
+     * @param {VertexId} v1 - The parameter `v1` is of type `VertexId` and represents the first vertex in the edge.
+     * @param {VertexId} v2 - The parameter `v2` is a `VertexId`, which represents the identifier of the second vertex in a
+     * graph.
+     * @param {number} [weight] - The `weight` parameter is an optional number that represents the weight of the edge
+     * between two vertices.
+     */
     constructor(v1: VertexId, v2: VertexId, weight?: number);
     private _vertices;
     get vertices(): [VertexId, VertexId];