data-structure-typed 1.12.10 → 1.12.21

package/src/data-structures/binary-tree/binary-tree.ts

@@ -1,9 +1,12 @@
 /**
- * @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 {trampoline} from '../../utils/trampoline';
+import {trampoline} from '../../utils';
 import type {
     BinaryTreeDeleted,
     BinaryTreeNodeId,
@@ -14,11 +17,19 @@ import type {
     ResultsByProperty
 } from '../types';
 
+/* This enumeration defines the position of a node within a family tree composed of three associated nodes, where 'root' represents the root node of the family tree, 'left' represents the left child node, and 'right' represents the right child node. */
 export enum FamilyPosition {root, left, right}
 
+/**
+ * Enum representing different loop types.
+ *
+ * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
+ * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
+ */
 export enum LoopType { iterative = 1, recursive = 2}
 
 export class BinaryTreeNode<T> {
+
     constructor(id: BinaryTreeNodeId, val: T, count?: number) {
         this._id = id;
         this._val = val;
@@ -239,58 +250,17 @@ export class BinaryTree<T> {
     }
 
     /**
-     * The function inserts a new node into a binary tree as the left or right child of a given parent node.
-     * @param {BinaryTreeNode<T> | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
-     * `null`. It represents the node that needs to be inserted into the binary tree.
-     * @param parent - The `parent` parameter is a BinaryTreeNode object representing the parent node to which the new node
-     * will be inserted as a child.
-     * @returns The method returns the newly inserted node, either as the left child or the right child of the parent node.
-     */
-    putTo(newNode: BinaryTreeNode<T> | null, parent: BinaryTreeNode<T> ) {
-        if (parent) {
-            if (parent.left === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                    newNode.familyPosition = FamilyPosition.left;
-                }
-                parent.left = newNode;
-                if (newNode !== null) {
-                    this.size++;
-                    this.count += newNode?.count ?? 0;
-                }
-
-                return parent.left;
-            } else if (parent.right === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                    newNode.familyPosition = FamilyPosition.right;
-                }
-                parent.right = newNode;
-                if (newNode !== null) {
-                    this.size++;
-                    this.count += newNode?.count ?? 0;
-                }
-                return parent.right;
-            } else {
-                return;
-            }
-        } else {
-            return;
-        }
-    }
-
-    /**
-     * The `put` function inserts a new node with a given ID and value into a binary tree, updating the count if the node
+     * The `add` function inserts a new node with a given ID and value into a binary tree, updating the count if the node
      * already exists.
      * @param {BinaryTreeNodeId} id - The id parameter is the identifier of the binary tree node. It is used to uniquely
      * identify each node in the binary tree.
      * @param {T} val - The value to be inserted into the binary tree.
      * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the
      * value should be inserted into the binary tree. If not provided, it defaults to 1.
-     * @returns The function `put` returns a `BinaryTreeNode<T>` object if a new node is inserted, or `null` if no new node
+     * @returns The function `add` returns a `BinaryTreeNode<T>` object if a new node is inserted, or `null` if no new node
      * is inserted, or `undefined` if the insertion fails.
      */
-    put(id: BinaryTreeNodeId, val: T, count?: number): BinaryTreeNode<T> | null | undefined {
+    add(id: BinaryTreeNodeId, val: T, count?: number): BinaryTreeNode<T> | null | undefined {
         count = count ?? 1;
 
         const _bfs = (root: BinaryTreeNode<T>, newNode: BinaryTreeNode<T> | null): BinaryTreeNode<T> | undefined | null => {
@@ -298,7 +268,7 @@ export class BinaryTree<T> {
             while (queue.length > 0) {
                 const cur = queue.shift();
                 if (cur) {
-                    const inserted = this.putTo(newNode, cur);
+                    const inserted = this.addTo(newNode, cur);
                     if (inserted !== undefined) return inserted;
                     if (cur.left) queue.push(cur.left);
                     if (cur.right) queue.push(cur.right);
@@ -333,13 +303,54 @@ export class BinaryTree<T> {
     }
 
     /**
-     * The `insertMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
+     * The function inserts a new node into a binary tree as the left or right child of a given parent node.
+     * @param {BinaryTreeNode<T> | null} newNode - The `newNode` parameter is an instance of the `BinaryTreeNode` class or
+     * `null`. It represents the node that needs to be inserted into the binary tree.
+     * @param parent - The `parent` parameter is a BinaryTreeNode object representing the parent node to which the new node
+     * will be inserted as a child.
+     * @returns The method returns the newly inserted node, either as the left child or the right child of the parent node.
+     */
+    addTo(newNode: BinaryTreeNode<T> | null, parent: BinaryTreeNode<T>) {
+        if (parent) {
+            if (parent.left === undefined) {
+                if (newNode) {
+                    newNode.parent = parent;
+                    newNode.familyPosition = FamilyPosition.left;
+                }
+                parent.left = newNode;
+                if (newNode !== null) {
+                    this.size++;
+                    this.count += newNode?.count ?? 0;
+                }
+
+                return parent.left;
+            } else if (parent.right === undefined) {
+                if (newNode) {
+                    newNode.parent = parent;
+                    newNode.familyPosition = FamilyPosition.right;
+                }
+                parent.right = newNode;
+                if (newNode !== null) {
+                    this.size++;
+                    this.count += newNode?.count ?? 0;
+                }
+                return parent.right;
+            } else {
+                return;
+            }
+        } else {
+            return;
+        }
+    }
+
+    /**
+     * The `addMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
      * null/undefined values.
      * @param {T[] | BinaryTreeNode<T>[]} data - The `data` parameter can be either an array of elements of type `T` or an
      * array of `BinaryTreeNode<T>` objects.
-     * @returns The function `insertMany` returns an array of `BinaryTreeNode<T>`, `null`, or `undefined` values.
+     * @returns The function `addMany` returns an array of `BinaryTreeNode<T>`, `null`, or `undefined` values.
      */
-    insertMany(data: T[] | BinaryTreeNode<T>[]): (BinaryTreeNode<T> | null | undefined)[] {
+    addMany(data: T[] | BinaryTreeNode<T>[]): (BinaryTreeNode<T> | null | undefined)[] {
         const inserted: (BinaryTreeNode<T> | null | undefined)[] = [];
         const map: Map<T | BinaryTreeNode<T>, number> = new Map();
 
@@ -351,28 +362,28 @@ export class BinaryTree<T> {
             const count = this._isDuplicatedVal ? 1 : map.get(item);
 
             if (item instanceof BinaryTreeNode) {
-                inserted.push(this.put(item.id, item.val, item.count));
+                inserted.push(this.add(item.id, item.val, item.count));
             } else if (typeof item === 'number' && !this._autoIncrementId) {
                 if (!this._isDuplicatedVal) {
                     if (map.get(item) !== undefined) {
-                        inserted.push(this.put(item, item, count));
+                        inserted.push(this.add(item, item, count));
                         map.delete(item);
                     }
                 } else {
-                    inserted.push(this.put(item, item, 1));
+                    inserted.push(this.add(item, item, 1));
                 }
             } else {
                 if (item !== null) {
                     if (!this._isDuplicatedVal) {
                         if (map.get(item) !== undefined) {
-                            inserted.push(this.put(++this._maxId, item, count));
+                            inserted.push(this.add(++this._maxId, item, count));
                             map.delete(item);
                         }
                     } else {
-                        inserted.push(this.put(++this._maxId, item, 1));
+                        inserted.push(this.add(++this._maxId, item, 1));
                     }
                 } else {
-                    inserted.push(this.put(Number.MAX_SAFE_INTEGER, item, 0));
+                    inserted.push(this.add(Number.MAX_SAFE_INTEGER, item, 0));
                 }
             }
         }
@@ -388,7 +399,7 @@ export class BinaryTree<T> {
      */
     fill(data: T[] | BinaryTreeNode<T>[]): boolean {
         this.clear();
-        return data.length === this.insertMany(data).length;
+        return data.length === this.addMany(data).length;
     }
 
     /**
@@ -718,6 +729,7 @@ export class BinaryTree<T> {
     }
 
     // --- start additional methods ---
+
     /**
      * The `isBST` function checks if a binary tree is a binary search tree.
      * @param {BinaryTreeNode<T> | null} [node] - The `node` parameter is an optional parameter of type `BinaryTreeNode<T>

package/src/data-structures/binary-tree/bst.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 {BinaryTreeNodeId, BinaryTreeNodePropertyName, BSTComparator, BSTDeletedResult} from '../types';
 import {BinaryTree, BinaryTreeNode, FamilyPosition, LoopType,} from './binary-tree';
@@ -14,6 +17,10 @@ export class BSTNode<T> extends BinaryTreeNode<T> {
 }
 
 export class BST<T> extends BinaryTree<T> {
+    /**
+     * 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:
+     */
     constructor(options?: {
         comparator?: BSTComparator,
         loopType?: LoopType
@@ -32,7 +39,7 @@ export class BST<T> extends BinaryTree<T> {
     }
 
     /**
-     * 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.
@@ -41,9 +48,9 @@ export class BST<T> extends BinaryTree<T> {
      * @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`.
      */
-    override put(id: BinaryTreeNodeId, val: T | null, count: number = 1): BSTNode<T> | null {
+    override add(id: BinaryTreeNodeId, val: T | null, count: number = 1): BSTNode<T> | null {
         let inserted: BSTNode<T> | null = null;
         const newNode = this.createNode(id, val, count);
         if (this.root === null) {
@@ -108,17 +115,44 @@ export class BST<T> extends BinaryTree<T> {
         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.
+     */
     override get(nodeProperty: BinaryTreeNodeId | T, propertyName ?: BinaryTreeNodePropertyName): BSTNode<T> | null {
         propertyName = propertyName ?? 'id';
         return this.getNodes(nodeProperty, propertyName, true)[0] ?? 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
+     */
     lastKey() {
         if (this._compare(0, 1) === CP.lt) return this.getRightMost()?.id ?? 0;
         else if (this._compare(0, 1) === CP.gt) return this.getLeftMost()?.id ?? 0;
         else return this.getRightMost()?.id ?? 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.
+     */
     override remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BSTDeletedResult<T>[] {
         const bstDeletedResult: BSTDeletedResult<T>[] = [];
         if (!this.root) return bstDeletedResult;
@@ -167,6 +201,19 @@ export class BST<T> extends BinaryTree<T> {
         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.
+     */
     override getNodes(nodeProperty: BinaryTreeNodeId | T, propertyName ?: BinaryTreeNodePropertyName, onlyOne ?: boolean): BSTNode<T>[] {
         propertyName = propertyName ?? 'id';
         if (!this.root) return [];
@@ -208,6 +255,16 @@ export class BST<T> extends BinaryTree<T> {
     }
 
     // --- 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`.
+     */
     lesserSum(id: BinaryTreeNodeId, propertyName ?: BinaryTreeNodePropertyName): number {
         propertyName = propertyName ?? 'id';
         if (!this.root) return 0;
@@ -273,6 +330,18 @@ export class BST<T> extends BinaryTree<T> {
         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.
+     */
     allGreaterNodesAdd(node: BSTNode<T>, delta: number, propertyName ?: BinaryTreeNodePropertyName): boolean {
         propertyName = propertyName ?? 'id';
         if (!this.root) return false;
@@ -319,6 +388,11 @@ export class BST<T> extends BinaryTree<T> {
         }
     }
 
+    /**
+     * 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.
+     */
     balance(): boolean {
         const sorted = this.DFS('in', 'node'), n = sorted.length;
         this.clear();
@@ -329,7 +403,7 @@ export class BST<T> extends BinaryTree<T> {
                 if (l > r) return;
                 const m = l + Math.floor((r - l) / 2);
                 const midNode = sorted[m];
-                this.put(midNode.id, midNode.val, midNode.count);
+                this.add(midNode.id, midNode.val, midNode.count);
                 buildBalanceBST(l, m - 1);
                 buildBalanceBST(m + 1, r);
             };
@@ -345,7 +419,7 @@ export class BST<T> extends BinaryTree<T> {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const 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]);
                     }
@@ -355,6 +429,11 @@ export class BST<T> extends BinaryTree<T> {
         }
     }
 
+    /**
+     * 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.
+     */
     isAVLBalanced(): boolean {
         if (!this.root) return true;
 
@@ -399,6 +478,14 @@ export class BST<T> extends BinaryTree<T> {
 
     protected _comparator: BSTComparator = (a, b) => a - b;
 
+    /**
+     * 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).
+     */
     protected _compare(a: BinaryTreeNodeId, b: BinaryTreeNodeId): CP {
         const compared = this._comparator(a, b);
         if (compared > 0) return CP.gt;

package/src/data-structures/binary-tree/segment-tree.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';
@@ -79,6 +82,15 @@ export class SegmentTree {
     protected _start = 0;
     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) {
         start = start || 0;
         end = end || values.length - 1;
@@ -94,6 +106,15 @@ export class SegmentTree {
         return this._root;
     }
 
+    /**
+     * 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 {
         if (start === end) {
             return new SegmentTreeNode(start, end, this._values[start]);
@@ -107,6 +128,17 @@ export class SegmentTree {
         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.
+     */
     updateNode(index: number, sum: number, val?: SegmentTreeNodeVal) {
         const root = this.root || null;
         if (!root) {
@@ -136,6 +168,13 @@ export class SegmentTree {
         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.
+     */
     querySumByRange(indexA: number, indexB: number): number {
         const root = this.root || null;
         if (!root) {

package/src/data-structures/binary-tree/tree-multiset.ts

@@ -1,19 +1,50 @@
 /**
- * @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 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).
+     */
     override createNode(id: BinaryTreeNodeId, val: T, count?: number): BSTNode<T> {
         return new BSTNode<T>(id, val, count);
     }
 
-    override put(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null {
-        return super.put(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`.
+     */
+    override add(id: BinaryTreeNodeId, val: T | null, count?: number): BSTNode<T> | null {
+        return super.add(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.
+     */
     override remove(id: BinaryTreeNodeId, isUpdateAllLeftSum?: boolean): TreeMultiSetDeletedResult<T>[] {
         return super.remove(id, isUpdateAllLeftSum);
     }

package/src/data-structures/graph/abstract-graph.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 {arrayRemove, uuidV4} from '../../utils';
 import {PriorityQueue} from '../priority-queue';
@@ -26,6 +29,11 @@ export abstract class AbstractEdge {
 
     static DEFAULT_EDGE_WEIGHT = 1;
 
+    /**
+     * 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) {
         if (weight === undefined) weight = AbstractEdge.DEFAULT_EDGE_WEIGHT;
         this._weight = weight;
@@ -535,7 +543,7 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
         }
 
         const heap = new PriorityQueue<{ id: number, val: V }>({comparator: (a, b) => a.id - b.id});
-        heap.offer({id: 0, val: srcVertex});
+        heap.add({id: 0, val: srcVertex});
 
         distMap.set(srcVertex, 0);
         preMap.set(srcVertex, null);
@@ -582,7 +590,7 @@ export abstract class AbstractGraph<V extends AbstractVertex, E extends Abstract
                                 const 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);
                                     }