data-structure-typed 1.34.6 → 1.34.8

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

@@ -1,8 +1,8 @@
 import { CP, LoopType } from '../../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 export class BSTNode extends BinaryTreeNode {
-    constructor(id, val) {
-        super(id, val);
+    constructor(key, val) {
+        super(key, val);
     }
 }
 export class BST extends BinaryTree {
@@ -21,36 +21,36 @@ export class BST extends BinaryTree {
         }
     }
     /**
-     * The function creates a new binary search tree node with the given id and value.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is the identifier for the binary tree node. It is used to uniquely
+     * The function creates a new binary search tree node with the given key and value.
+     * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier for the binary tree node. It is used to uniquely
      * identify each node in the binary tree.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the node. It represents the value
      * that will be stored in the node.
-     * @returns a new instance of the BSTNode class with the specified id and value.
+     * @returns a new instance of the BSTNode class with the specified key and value.
      */
-    createNode(id, val) {
-        return new BSTNode(id, val);
+    createNode(key, val) {
+        return new BSTNode(key, val);
     }
     /**
      * The `add` function adds a new node to a binary search tree, either by creating a new node or by updating an existing
      * node with the same ID.
-     * @param {BinaryTreeNodeId | N | null} idOrNode - The `idOrNode` parameter can be either a `BinaryTreeNodeId` or a `N`
+     * @param {BinaryTreeNodeKey | N | null} keyOrNode - The `keyOrNode` parameter can be either a `BinaryTreeNodeKey` or a `N`
      * (which represents a binary tree node) or `null`.
      * @param [val] - The `val` parameter is an optional value that can be assigned to the `val` property of the new node
      * being added to the binary search tree.
      * @returns The function `add` returns the inserted node (`inserted`) which can be of type `N`, `null`, or `undefined`.
      */
-    add(idOrNode, val) {
+    add(keyOrNode, val) {
         // TODO support node as a param
         let inserted = null;
         let newNode = null;
-        if (idOrNode instanceof BSTNode) {
-            newNode = idOrNode;
+        if (keyOrNode instanceof BSTNode) {
+            newNode = keyOrNode;
         }
-        else if (typeof idOrNode === 'number') {
-            newNode = this.createNode(idOrNode, val);
+        else if (typeof keyOrNode === 'number') {
+            newNode = this.createNode(keyOrNode, val);
         }
-        else if (idOrNode === null) {
+        else if (keyOrNode === null) {
             newNode = null;
         }
         if (this.root === null) {
@@ -63,7 +63,7 @@ export class BST extends BinaryTree {
             let traversing = true;
             while (traversing) {
                 if (cur !== null && newNode !== null) {
-                    if (this._compare(cur.id, newNode.id) === CP.eq) {
+                    if (this._compare(cur.key, newNode.key) === CP.eq) {
                         if (newNode) {
                             cur.val = newNode.val;
                         }
@@ -71,7 +71,7 @@ export class BST extends BinaryTree {
                         traversing = false;
                         inserted = cur;
                     }
-                    else if (this._compare(cur.id, newNode.id) === CP.gt) {
+                    else if (this._compare(cur.key, newNode.key) === CP.gt) {
                         // Traverse left of the node
                         if (cur.left === undefined) {
                             if (newNode) {
@@ -89,7 +89,7 @@ export class BST extends BinaryTree {
                                 cur = cur.left;
                         }
                     }
-                    else if (this._compare(cur.id, newNode.id) === CP.lt) {
+                    else if (this._compare(cur.key, newNode.key) === CP.lt) {
                         // Traverse right of the node
                         if (cur.right === undefined) {
                             if (newNode) {
@@ -118,8 +118,8 @@ export class BST extends BinaryTree {
     /**
      * The `addMany` function overrides the base class method to add multiple nodes to a binary search tree in a balanced
      * manner.
-     * @param {[BinaryTreeNodeId | N , N['val']][]} idsOrNodes - The `idsOrNodes` parameter in the `addMany` function is an array of
-     * `BinaryTreeNodeId` or `N` (node) objects, or `null` values. It represents the nodes or node IDs that need to be added
+     * @param {[BinaryTreeNodeKey | N , N['val']][]} idsOrNodes - The `idsOrNodes` parameter in the `addMany` function is an array of
+     * `BinaryTreeNodeKey` or `N` (node) objects, or `null` values. It represents the nodes or node IDs that need to be added
      * to the binary search tree.
      * @param {N['val'][]} data - The values of tree nodes
      * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
@@ -136,28 +136,28 @@ export class BST extends BinaryTree {
         const combinedArr = idsOrNodes.map((value, index) => [value, data === null || data === void 0 ? void 0 : data[index]]);
         let sorted = [];
         function isNodeOrNullTuple(arr) {
-            for (const [idOrNode] of arr)
-                if (idOrNode instanceof BSTNode)
+            for (const [keyOrNode] of arr)
+                if (keyOrNode instanceof BSTNode)
                     return true;
             return false;
         }
-        function isBinaryTreeIdOrNullTuple(arr) {
-            for (const [idOrNode] of arr)
-                if (typeof idOrNode === 'number')
+        function isBinaryTreeKeyOrNullTuple(arr) {
+            for (const [keyOrNode] of arr)
+                if (typeof keyOrNode === 'number')
                     return true;
             return false;
         }
-        let sortedIdsOrNodes = [], sortedData = [];
+        let sortedKeysOrNodes = [], sortedData = [];
         if (isNodeOrNullTuple(combinedArr)) {
-            sorted = combinedArr.sort((a, b) => a[0].id - b[0].id);
+            sorted = combinedArr.sort((a, b) => a[0].key - b[0].key);
         }
-        else if (isBinaryTreeIdOrNullTuple(combinedArr)) {
+        else if (isBinaryTreeKeyOrNullTuple(combinedArr)) {
             sorted = combinedArr.sort((a, b) => a[0] - b[0]);
         }
         else {
             throw new Error('Invalid input idsOrNodes');
         }
-        sortedIdsOrNodes = sorted.map(([idOrNode]) => idOrNode);
+        sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
         sortedData = sorted.map(([, val]) => val);
         const recursive = (arr, data) => {
             if (arr.length === 0)
@@ -177,7 +177,7 @@ export class BST extends BinaryTree {
                     const [l, r] = popped;
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
-                        const newNode = this.add(sortedIdsOrNodes[m], sortedData === null || sortedData === void 0 ? void 0 : sortedData[m]);
+                        const newNode = this.add(sortedKeysOrNodes[m], sortedData === null || sortedData === void 0 ? void 0 : sortedData[m]);
                         inserted.push(newNode);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
@@ -186,7 +186,7 @@ export class BST extends BinaryTree {
             }
         };
         if (this.loopType === LoopType.RECURSIVE) {
-            recursive(sortedIdsOrNodes, sortedData);
+            recursive(sortedKeysOrNodes, sortedData);
         }
         else {
             iterative();
@@ -195,45 +195,45 @@ export class BST extends BinaryTree {
     }
     /**
      * The function returns the first node in a binary tree that matches the given property name and value.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
      * generic type `N`. It represents the property of the binary tree node that you want to search for.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name to use for searching the binary tree nodes. If not provided, it defaults to `'id'`.
-     * @returns The method is returning either a BinaryTreeNodeId or N (generic type) or null.
+     * specifies the property name to use for searching the binary tree nodes. If not provided, it defaults to `'key'`.
+     * @returns The method is returning either a BinaryTreeNodeKey or N (generic type) or null.
      */
     get(nodeProperty, propertyName) {
         var _a;
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'key';
         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 method `lastKey()` returns the id of the rightmost node in the binary tree if the comparison between
-     * the values at index 0 and 1 is less than, otherwise it returns the id of the leftmost node. If the comparison is
-     * equal, it returns the id of the rightmost node. If there are no nodes in the tree, it returns 0.
+     * The function returns the key of the rightmost node if the comparison between two values is less than, the key of the
+     * leftmost node if the comparison is greater than, and the key of the rightmost node otherwise.
+     * @returns The method `lastKey()` returns the key of the rightmost node in the binary tree if the comparison between
+     * the values at index 0 and 1 is less than, otherwise it returns the key of the leftmost node. If the comparison is
+     * equal, it returns the key of the rightmost node. If there are no nodes in the tree, it returns 0.
      */
     lastKey() {
         var _a, _b, _c, _d, _e, _f;
         if (this._compare(0, 1) === CP.lt)
-            return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : 0;
+            return (_b = (_a = this.getRightMost()) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : 0;
         else if (this._compare(0, 1) === CP.gt)
-            return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.id) !== null && _d !== void 0 ? _d : 0;
+            return (_d = (_c = this.getLeftMost()) === null || _c === void 0 ? void 0 : _c.key) !== null && _d !== void 0 ? _d : 0;
         else
-            return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.id) !== null && _f !== void 0 ? _f : 0;
+            return (_f = (_e = this.getRightMost()) === null || _e === void 0 ? void 0 : _e.key) !== null && _f !== void 0 ? _f : 0;
     }
     /**
      * The function `getNodes` returns an array of nodes in a binary tree that match a given property value.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or an
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or an
      * `N` type. It represents the property of the binary tree node that you want to compare with.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name to use for comparison. If not provided, it defaults to `'id'`.
+     * specifies the property name to use for comparison. If not provided, it defaults to `'key'`.
      * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
      * return only one node that matches the given `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne`
      * is set to `true`, the function will return an array with only one node (if
      * @returns an array of nodes (type N).
      */
-    getNodes(nodeProperty, propertyName = 'id', onlyOne) {
+    getNodes(nodeProperty, propertyName = 'key', onlyOne) {
         if (!this.root)
             return [];
         const result = [];
@@ -243,10 +243,10 @@ export class BST extends BinaryTree {
                     return;
                 if (!cur.left && !cur.right)
                     return;
-                if (propertyName === 'id') {
-                    if (this._compare(cur.id, nodeProperty) === CP.gt)
+                if (propertyName === 'key') {
+                    if (this._compare(cur.key, nodeProperty) === CP.gt)
                         cur.left && _traverse(cur.left);
-                    if (this._compare(cur.id, nodeProperty) === CP.lt)
+                    if (this._compare(cur.key, nodeProperty) === CP.lt)
                         cur.right && _traverse(cur.right);
                 }
                 else {
@@ -263,10 +263,10 @@ export class BST extends BinaryTree {
                 if (cur) {
                     if (this._pushByPropertyNameStopOrNot(cur, result, nodeProperty, propertyName, onlyOne))
                         return result;
-                    if (propertyName === 'id') {
-                        if (this._compare(cur.id, nodeProperty) === CP.gt)
+                    if (propertyName === 'key') {
+                        if (this._compare(cur.key, nodeProperty) === CP.gt)
                             cur.left && queue.push(cur.left);
-                        if (this._compare(cur.id, nodeProperty) === CP.lt)
+                        if (this._compare(cur.key, nodeProperty) === CP.lt)
                             cur.right && queue.push(cur.right);
                     }
                     else {
@@ -282,29 +282,29 @@ export class BST extends BinaryTree {
     /**
      * The `lesserSum` function calculates the sum of property values in a binary tree for nodes that have a property value
      * less than a given node.
-     * @param {N | BinaryTreeNodeId | null} beginNode - The `beginNode` parameter can be one of the following:
+     * @param {N | BinaryTreeNodeKey | null} beginNode - The `beginNode` parameter can be one of the following:
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
-     * specifies the property name to use for calculating the sum. If not provided, it defaults to `'id'`.
+     * specifies the property name to use for calculating the sum. If not provided, it defaults to `'key'`.
      * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in the
      * binary tree that have a lesser value than the specified `beginNode` based on the `propertyName`.
      */
     lesserSum(beginNode, propertyName) {
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'key';
         if (typeof beginNode === 'number')
-            beginNode = this.get(beginNode, 'id');
+            beginNode = this.get(beginNode, 'key');
         if (!beginNode)
             return 0;
         if (!this.root)
             return 0;
-        const id = beginNode.id;
+        const key = beginNode.key;
         const getSumByPropertyName = (cur) => {
             let needSum;
             switch (propertyName) {
-                case 'id':
-                    needSum = cur.id;
+                case 'key':
+                    needSum = cur.key;
                     break;
                 default:
-                    needSum = cur.id;
+                    needSum = cur.key;
                     break;
             }
             return needSum;
@@ -312,7 +312,7 @@ export class BST extends BinaryTree {
         let sum = 0;
         if (this.loopType === LoopType.RECURSIVE) {
             const _traverse = (cur) => {
-                const compared = this._compare(cur.id, id);
+                const compared = this._compare(cur.key, key);
                 if (compared === CP.eq) {
                     if (cur.right)
                         sum += this.subTreeSum(cur.right, propertyName);
@@ -341,7 +341,7 @@ export class BST extends BinaryTree {
             while (queue.length > 0) {
                 const cur = queue.shift();
                 if (cur) {
-                    const compared = this._compare(cur.id, id);
+                    const compared = this._compare(cur.key, key);
                     if (compared === CP.eq) {
                         if (cur.right)
                             sum += this.subTreeSum(cur.right, propertyName);
@@ -371,44 +371,44 @@ export class BST extends BinaryTree {
     /**
      * The `allGreaterNodesAdd` function adds a delta value to the specified property of all nodes in a binary tree that
      * have a greater value than a given node.
-     * @param {N | BinaryTreeNodeId | null} node - The `node` parameter can be either of type `N` (a generic type),
-     * `BinaryTreeNodeId`, or `null`. It represents the node in the binary tree to which the delta value will be added.
+     * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be either of type `N` (a generic type),
+     * `BinaryTreeNodeKey`, or `null`. It represents the node in the binary tree to which the delta value will be added.
      * @param {number} delta - The `delta` parameter is a number that represents the amount by which the property value of
      * each greater node should be increased.
      * @param {BinaryTreeNodePropertyName} [propertyName] - The `propertyName` parameter is an optional parameter that
      * specifies the property name of the nodes in the binary tree that you want to update. If not provided, it defaults to
-     * 'id'.
+     * 'key'.
      * @returns a boolean value.
      */
     allGreaterNodesAdd(node, delta, propertyName) {
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'id';
+        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'key';
         if (typeof node === 'number')
-            node = this.get(node, 'id');
+            node = this.get(node, 'key');
         if (!node)
             return false;
-        const id = node.id;
+        const key = node.key;
         if (!this.root)
             return false;
         const _sumByPropertyName = (cur) => {
             switch (propertyName) {
-                case 'id':
-                    cur.id += delta;
+                case 'key':
+                    cur.key += delta;
                     break;
                 default:
-                    cur.id += delta;
+                    cur.key += delta;
                     break;
             }
         };
         if (this.loopType === LoopType.RECURSIVE) {
             const _traverse = (cur) => {
-                const compared = this._compare(cur.id, id);
+                const compared = this._compare(cur.key, key);
                 if (compared === CP.gt)
                     _sumByPropertyName(cur);
                 if (!cur.left && !cur.right)
                     return;
-                if (cur.left && this._compare(cur.left.id, id) === CP.gt)
+                if (cur.left && this._compare(cur.left.key, key) === CP.gt)
                     _traverse(cur.left);
-                if (cur.right && this._compare(cur.right.id, id) === CP.gt)
+                if (cur.right && this._compare(cur.right.key, key) === CP.gt)
                     _traverse(cur.right);
             };
             _traverse(this.root);
@@ -419,12 +419,12 @@ export class BST extends BinaryTree {
             while (queue.length > 0) {
                 const cur = queue.shift();
                 if (cur) {
-                    const compared = this._compare(cur.id, id);
+                    const compared = this._compare(cur.key, key);
                     if (compared === CP.gt)
                         _sumByPropertyName(cur);
-                    if (cur.left && this._compare(cur.left.id, id) === CP.gt)
+                    if (cur.left && this._compare(cur.left.key, key) === CP.gt)
                         queue.push(cur.left);
-                    if (cur.right && this._compare(cur.right.id, id) === CP.gt)
+                    if (cur.right && this._compare(cur.right.key, key) === CP.gt)
                         queue.push(cur.right);
                 }
             }
@@ -456,7 +456,7 @@ export class BST extends BinaryTree {
                     return;
                 const m = l + Math.floor((r - l) / 2);
                 const midNode = sorted[m];
-                this.add(midNode.id, midNode.val);
+                this.add(midNode.key, midNode.val);
                 buildBalanceBST(l, m - 1);
                 buildBalanceBST(m + 1, r);
             };
@@ -472,7 +472,7 @@ export class BST extends BinaryTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        this.add(midNode.id, midNode.val);
+                        this.add(midNode.key, midNode.val);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -534,8 +534,8 @@ export class BST extends BinaryTree {
     /**
      * 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.
+     * @param {BinaryTreeNodeKey} a - a is a BinaryTreeNodeKey, which represents the identifier of a binary tree node.
+     * @param {BinaryTreeNodeKey} b - The parameter "b" in the above code refers to a BinaryTreeNodeKey.
      * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater than), CP.lt (less
      * than), or CP.eq (equal).
      */

package/lib/data-structures/binary-tree/rb-tree.d.ts

@@ -1,13 +1,13 @@
-import { BinaryTreeNodeId, RBColor, RBTreeNodeNested, RBTreeOptions } from '../../types';
+import { BinaryTreeNodeKey, RBColor, RBTreeNodeNested, RBTreeOptions } from '../../types';
 import { IRBTree, IRBTreeNode } from '../../interfaces';
 import { BST, BSTNode } from './bst';
 export declare class RBTreeNode<V = any, NEIGHBOR extends RBTreeNode<V, NEIGHBOR> = RBTreeNodeNested<V>> extends BSTNode<V, NEIGHBOR> implements IRBTreeNode<V, NEIGHBOR> {
     private _color;
-    constructor(id: BinaryTreeNodeId, val?: V);
+    constructor(key: BinaryTreeNodeKey, val?: V);
     get color(): RBColor;
     set color(value: RBColor);
 }
 export declare class RBTree<N extends RBTreeNode<N['val'], N> = RBTreeNode> extends BST<N> implements IRBTree<N> {
     constructor(options?: RBTreeOptions);
-    createNode(id: BinaryTreeNodeId, val?: N['val']): N;
+    createNode(key: BinaryTreeNodeKey, val?: N['val']): N;
 }

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

@@ -1,8 +1,8 @@
 import { RBColor } from '../../types';
 import { BST, BSTNode } from './bst';
 export class RBTreeNode extends BSTNode {
-    constructor(id, val) {
-        super(id, val);
+    constructor(key, val) {
+        super(key, val);
         this._color = RBColor.RED;
     }
     get color() {
@@ -16,7 +16,7 @@ export class RBTree extends BST {
     constructor(options) {
         super(options);
     }
-    createNode(id, val) {
-        return new RBTreeNode(id, val);
+    createNode(key, val) {
+        return new RBTreeNode(key, val);
     }
 }

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

@@ -5,14 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { BinaryTreeNodeId, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
+import type { BinaryTreeNodeKey, TreeMultisetNodeNested, TreeMultisetOptions } from '../../types';
 import { BinaryTreeDeletedResult, DFSOrderPattern } from '../../types';
 import { ITreeMultiset, ITreeMultisetNode } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export declare class TreeMultisetNode<V = any, NEIGHBOR extends TreeMultisetNode<V, NEIGHBOR> = TreeMultisetNodeNested<V>> extends AVLTreeNode<V, NEIGHBOR> implements ITreeMultisetNode<V, NEIGHBOR> {
     /**
-     * The constructor function initializes a BinaryTreeNode object with an id, value, and count.
-     * @param {BinaryTreeNodeId} id - The `id` parameter is of type `BinaryTreeNodeId` and represents the unique identifier
+     * The constructor function initializes a BinaryTreeNode object with an key, value, and count.
+     * @param {BinaryTreeNodeKey} key - The `key` parameter is of type `BinaryTreeNodeKey` and represents the unique identifier
      * of the binary tree node.
      * @param {V} [val] - The `val` parameter is an optional parameter of type `V`. It represents the value of the binary
      * tree node. If no value is provided, it will be `undefined`.
@@ -20,7 +20,7 @@ export declare class TreeMultisetNode<V = any, NEIGHBOR extends TreeMultisetNode
      * occurs in a binary tree node. It has a default value of 1, which means that if no value is provided for the `count`
      * parameter when creating a new instance of the `BinaryTreeNode` class,
      */
-    constructor(id: BinaryTreeNodeId, val?: V, count?: number);
+    constructor(key: BinaryTreeNodeKey, val?: V, count?: number);
     private _count;
     get count(): number;
     set count(v: number);
@@ -39,15 +39,15 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
     private _count;
     get count(): number;
     /**
-     * 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
+     * The function creates a new BSTNode with the given key, value, and count.
+     * @param {BinaryTreeNodeKey} key - The key parameter is the unique identifier for the binary tree node. It is used to
      * distinguish one node from another in the tree.
      * @param {N} 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).
+     * @returns A new instance of the BSTNode class with the specified key, value, and count (if provided).
      */
-    createNode(id: BinaryTreeNodeId, val?: N['val'], count?: number): N;
+    createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N;
     /**
      * The function swaps the location of two nodes in a tree data structure.
      * @param {N} srcNode - The source node that we want to swap with the destination node.
@@ -59,14 +59,14 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
     /**
      * The `add` function adds a new node to a binary search tree, maintaining the tree's properties and balancing if
      * necessary.
-     * @param {BinaryTreeNodeId | N} idOrNode - The `idOrNode` parameter can be either a `BinaryTreeNodeId` or a `N` (which
+     * @param {BinaryTreeNodeKey | N} keyOrNode - The `keyOrNode` parameter can be either a `BinaryTreeNodeKey` or a `N` (which
      * represents a `BinaryTreeNode`).
      * @param [val] - The `val` parameter represents the value to be added to the binary tree node.
      * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the
      * value should be added to the binary tree. If the `count` parameter is not provided, it defaults to 1.
      * @returns The method `add` returns either the inserted node (`N`), `null`, or `undefined`.
      */
-    add(idOrNode: BinaryTreeNodeId | N | null, val?: N['val'], count?: number): N | null | undefined;
+    add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val'], count?: number): N | null | undefined;
     /**
      * The function adds a new node to a binary tree if there is an available slot on the left or right side of the parent
      * node.
@@ -80,14 +80,14 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
     /**
      * The `addMany` function takes an array of node IDs or nodes and adds them to the tree multiset, returning an array of
      * the inserted nodes.
-     * @param {(BinaryTreeNodeId | null)[] | (N | null)[]} idsOrNodes - An array of BinaryTreeNodeId or BinaryTreeNode
+     * @param {(BinaryTreeNodeKey | null)[] | (N | null)[]} idsOrNodes - An array of BinaryTreeNodeKey or BinaryTreeNode
      * objects, or null values.
      * @param {N['val'][]} [data] - The `data` parameter is an optional array of values (`N['val'][]`) that corresponds to
-     * the nodes being added. It is used when adding nodes using the `idOrNode` and `data` arguments in the `this.add()`
+     * the nodes being added. It is used when adding nodes using the `keyOrNode` and `data` arguments in the `this.add()`
      * method. If provided, the `data` array should
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(idsOrNodes: (BinaryTreeNodeId | null)[] | (N | null)[], data?: N['val'][]): (N | null | undefined)[];
+    addMany(idsOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[], data?: N['val'][]): (N | null | undefined)[];
     /**
      * The `perfectlyBalance` function takes a binary tree, performs a depth-first search to sort the nodes, and then
      * constructs a balanced binary search tree using either a recursive or iterative approach.
@@ -97,13 +97,13 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
     /**
      * The `remove` function removes a node from a binary search tree and returns the deleted node along with the parent
      * node that needs to be balanced.
-     * @param {N | BinaryTreeNodeId | null} nodeOrId - The `nodeOrId` parameter can be one of the following:
+     * @param {N | BinaryTreeNodeKey | null} nodeOrKey - The `nodeOrKey` parameter can be one of the following:
      * @param {boolean} [ignoreCount] - The `ignoreCount` parameter is an optional boolean parameter that determines
      * whether to ignore the count of the node being removed. If `ignoreCount` is set to `true`, the count of the node will
      * not be taken into account when removing it. If `ignoreCount` is set to `false
      * @returns The function `remove` returns an array of `BinaryTreeDeletedResult<N>` objects.
      */
-    remove(nodeOrId: N | BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
+    remove(nodeOrKey: N | BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
     /**
      * The function `getSubTreeCount` calculates the number of nodes and the sum of their counts in a subtree, using either
      * recursive or iterative traversal.
@@ -115,34 +115,34 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
     /**
      * The function `subTreeSumCount` calculates the sum of the `count` property of each node in a subtree, either
      * recursively or iteratively.
-     * @param {N | BinaryTreeNodeId | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
-     * in a binary tree. It can be either a `BinaryTreeNodeId` (a unique identifier for a node in the binary tree) or
+     * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
+     * in a binary tree. It can be either a `BinaryTreeNodeKey` (a unique identifier for a node in the binary tree) or
      * `null` if the subtree is empty.
      * @returns the sum of the count values of all nodes in the subtree rooted at `subTreeRoot`.
      */
-    subTreeSumCount(subTreeRoot: N | BinaryTreeNodeId | null): number;
+    subTreeSumCount(subTreeRoot: N | BinaryTreeNodeKey | null): number;
     /**
      * The function `subTreeAddCount` recursively or iteratively traverses a binary tree and adds a given delta value to
      * the `count` property of each node.
-     * @param {N | BinaryTreeNodeId | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
-     * in a binary tree. It can be either a `BinaryTreeNodeId` (a unique identifier for a node in the binary tree), a
+     * @param {N | BinaryTreeNodeKey | null} subTreeRoot - The `subTreeRoot` parameter represents the root node of a subtree
+     * in a binary tree. It can be either a `BinaryTreeNodeKey` (a unique identifier for a node in the binary tree), a
      * `BinaryTreeNode` object, or `null` if the subtree is empty.
      * @param {number} delta - The delta parameter is a number that represents the amount by which the count of each node
      * in the subtree should be increased or decreased.
      * @returns a boolean value.
      */
-    subTreeAddCount(subTreeRoot: N | BinaryTreeNodeId | null, delta: number): boolean;
+    subTreeAddCount(subTreeRoot: N | BinaryTreeNodeKey | null, delta: number): boolean;
     /**
      * The function `getNodesByCount` returns an array of nodes that have a specific count property, either recursively or
      * using a queue.
-     * @param {BinaryTreeNodeId | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeId` or a
+     * @param {BinaryTreeNodeKey | N} nodeProperty - The `nodeProperty` parameter can be either a `BinaryTreeNodeKey` or a
      * `N`. It represents the property of the nodes that you want to search for.
      * @param {boolean} [onlyOne] - The `onlyOne` parameter is an optional boolean parameter that determines whether to
      * return only one node that matches the `nodeProperty` or all nodes that match the `nodeProperty`. If `onlyOne` is set
      * to `true`, the function will return only one node. If `onlyOne`
      * @returns an array of nodes that match the given nodeProperty.
      */
-    getNodesByCount(nodeProperty: BinaryTreeNodeId | N, onlyOne?: boolean): N[];
+    getNodesByCount(nodeProperty: BinaryTreeNodeKey | N, onlyOne?: boolean): N[];
     /**
      * The BFSCount function returns an array of counts from a breadth-first search of nodes.
      * @returns The BFSCount() function returns an array of numbers, specifically the count property of each node in the
@@ -186,19 +186,19 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
     /**
      * The `lesserSumCount` function calculates the sum of the counts of all nodes in a binary tree that have a lesser
      * value than a given node.
-     * @param {N | BinaryTreeNodeId | null} beginNode - The `beginNode` parameter can be one of the following:
+     * @param {N | BinaryTreeNodeKey | null} beginNode - The `beginNode` parameter can be one of the following:
      * @returns the sum of the counts of nodes in the binary tree that have a lesser value than the given beginNode.
      */
-    lesserSumCount(beginNode: N | BinaryTreeNodeId | null): number;
+    lesserSumCount(beginNode: N | BinaryTreeNodeKey | null): number;
     /**
      * The function `allGreaterNodesAddCount` updates the count property of all nodes in a binary tree that have an ID
      * greater than a given ID by a specified delta value.
-     * @param {N | BinaryTreeNodeId | null} node - The `node` parameter can be one of the following:
+     * @param {N | BinaryTreeNodeKey | null} node - The `node` parameter can be one of the following:
      * @param {number} delta - The `delta` parameter is a number that represents the amount by which the `count` property
      * of each node should be increased.
      * @returns a boolean value.
      */
-    allGreaterNodesAddCount(node: N | BinaryTreeNodeId | null, delta: number): boolean;
+    allGreaterNodesAddCount(node: N | BinaryTreeNodeKey | null, delta: number): boolean;
     /**
      * The clear() function clears the data and sets the count to 0.
      */