data-structure-typed 1.12.9 → 1.12.11

package/README.md

@@ -15,6 +15,13 @@ yarn add data-structure-typed
 ```bash
 npm install data-structure-typed
 ```
+## Online examples
+
+[Online Examples](https://data-structure-typed-examples.vercel.app)
+
+## Examples Repository
+
+[Example Repository](https://github.com/zrwusa/data-structure-typed-examples)
 
 ## api docs
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.12.9",
+  "version": "1.12.11",
   "description": "Explore our comprehensive Javascript Data Structure / TypeScript Data Structure Library, meticulously crafted to empower developers with a versatile set of essential data structures. Our library includes a wide range of data structures, such as Binary Tree, AVL Tree, Binary Search Tree (BST), Tree Multiset, Segment Tree, Binary Indexed Tree, Graph, Directed Graph, Undirected Graph, Singly Linked List, Hash, CoordinateSet, CoordinateMap, Heap, Doubly Linked List, Priority Queue, Max Priority Queue, Min Priority Queue, Queue, ObjectDeque, ArrayDeque, Stack, and Trie. Each data structure is thoughtfully designed and implemented using TypeScript to provide efficient, reliable, and easy-to-use solutions for your programming needs. Whether you're optimizing algorithms, managing data, or enhancing performance, our TypeScript Data Structure Library is your go-to resource. Elevate your coding experience with these fundamental building blocks for software development.",
   "main": "dist/index.js",
   "scripts": {
@@ -39,8 +39,8 @@
     "Min Priority Queue",
     "Trie"
   ],
-  "author": "Tyler Zeng",
-  "license": "ISC",
+  "author": "Tyler Zeng zrwusa@gmail.com",
+  "license": "MIT",
   "bugs": {
     "url": "https://github.com/zrwusa/data-structure-typed/issues"
   },

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

@@ -1,11 +1,20 @@
 /**
- * @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 {AVLTreeDeleted, BinaryTreeNodeId} from '../types';
 
 export class AVLTreeNode<T> extends BSTNode<T> {
+    /**
+     * The function overrides the clone method of the AVLTreeNode class to create a new AVLTreeNode object with the same
+     * id, value, and count.
+     * @returns The method is returning a new instance of the AVLTreeNode class with the same id, val, and count values as
+     * the current instance.
+     */
     override clone(): AVLTreeNode<T> {
         return new AVLTreeNode<T>(this.id, this.val, this.count);
     }
@@ -18,9 +27,9 @@ export class AVLTree<T> extends BST<T> {
     }
 
     /**
-     * The function overrides the put method of a Binary Search Tree to insert a node with a given id and value, and then
+     * The function overrides the add method of a Binary Search Tree to insert a node with a given id and value, and then
      * balances the tree.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to put or
+     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier of the binary tree node that we want to add or
      * update in the AVL tree.
      * @param {T | null} val - The `val` parameter represents the value that you want to assign to the node with the given
      * `id`. It can be of type `T` (the generic type) or `null`.
@@ -29,8 +38,8 @@ export class AVLTree<T> extends BST<T> {
      * to `1`, indicating that the value should be inserted once.
      * @returns The method is returning either an AVLTreeNode<T> object or null.
      */
-    override put(id: BinaryTreeNodeId, val: T | null, count?: number): AVLTreeNode<T> | null {
-        const inserted = super.put(id, val, count);
+    override add(id: BinaryTreeNodeId, val: T | null, count?: number): AVLTreeNode<T> | null {
+        const inserted = super.add(id, val, count);
         if (inserted) this.balancePath(inserted);
         return inserted;
     }

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

@@ -1,10 +1,19 @@
 /**
- * @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
  */
 export class BinaryIndexedTree {
     private readonly _sumTree: number[];
 
+    /**
+     * The constructor initializes an array with a specified length and fills it with zeros.
+     * @param {number} n - The parameter `n` represents the size of the array that will be used to store the sum tree. The
+     * sum tree is a binary tree data structure used to efficiently calculate the sum of a range of elements in an array.
+     * The size of the sum tree array is `n + 1` because
+     */
     constructor(n: number) {
         this._sumTree = new Array<number>(n + 1).fill(0);
     }

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);
     }