data-structure-typed 1.34.7 → 1.34.9

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

@@ -5,25 +5,23 @@
  * @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 a 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`.
      * @param {number} [count=1] - The `count` parameter is a number that represents the number of times a particular value
      * 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,
+     * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
-    constructor(id: BinaryTreeNodeId, val?: V, count?: number);
-    private _count;
-    get count(): number;
-    set count(v: number);
+    constructor(key: BinaryTreeNodeKey, val?: V, count?: number);
+    count: number;
 }
 /**
  * The only distinction between a TreeMultiset and a AVLTree lies in the ability of the former to store duplicate nodes through the utilization of counters.
@@ -39,15 +37,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 +57,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 +78,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)[]} keysOrNodes - 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(keysOrNodes: (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 +95,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,38 +113,38 @@ 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
-     * BFS traversal.
+     * bfs traversal.
      */
     BFSCount(): number[];
     /**
@@ -165,40 +163,40 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      * traversal pattern for the Morris traversal algorithm. It can have one of three values: 'in', 'pre', or 'post'.
      * @returns The function `morrisCount` returns an array of numbers.
      */
-    morrisCount(pattern?: 'in' | 'pre' | 'post'): number[];
+    morrisCount(pattern?: DFSOrderPattern): number[];
     /**
-     * The function DFSIterativeCount performs an iterative depth-first search and returns an array of node counts based on
+     * The function dfsCountIterative performs an iterative depth-first search and returns an array of node counts based on
      * the specified traversal pattern.
      * @param {'in' | 'pre' | 'post'} [pattern] - The pattern parameter is a string that specifies the traversal order for
-     * the Depth-First Search (DFS) algorithm. It can have three possible values: 'in', 'pre', or 'post'.
-     * @returns The DFSIterativeCount function returns an array of numbers, which represents the count property of each node
-     * in the DFS traversal.
+     * the Depth-First Search (dfs) algorithm. It can have three possible values: 'in', 'pre', or 'post'.
+     * @returns The dfsCountIterative function returns an array of numbers, which represents the count property of each node
+     * in the dfs traversal.
      */
-    DFSIterativeCount(pattern?: 'in' | 'pre' | 'post'): number[];
+    dfsCountIterative(pattern?: DFSOrderPattern): number[];
     /**
-     * The DFSCount function returns an array of counts for each node in a depth-first search traversal.
+     * The dfsCount function returns an array of counts for each node in a depth-first search traversal.
      * @param {DFSOrderPattern} [pattern] - The pattern parameter is an optional parameter that specifies the order in which
-     * the Depth-First Search (DFS) algorithm should traverse the nodes. It can have one of the following values:
-     * @returns The DFSCount function returns an array of numbers, specifically the count property of each node in the DFS
+     * the Depth-First Search (dfs) algorithm should traverse the nodes. It can have one of the following values:
+     * @returns The dfsCount function returns an array of numbers, specifically the count property of each node in the dfs
      * traversal.
      */
-    DFSCount(pattern?: DFSOrderPattern): number[];
+    dfsCount(pattern?: DFSOrderPattern): number[];
     /**
      * 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.
      */

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

@@ -2,24 +2,18 @@ import { CP, FamilyPosition, LoopType } from '../../types';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 export class TreeMultisetNode extends AVLTreeNode {
     /**
-     * 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 a 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`.
      * @param {number} [count=1] - The `count` parameter is a number that represents the number of times a particular value
      * 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,
+     * parameter when creating a new instance of the `BinaryTreeNode` class.
      */
-    constructor(id, val, count = 1) {
-        super(id, val);
-        this._count = count;
-    }
-    get count() {
-        return this._count;
-    }
-    set count(v) {
-        this._count = v;
+    constructor(key, val, count = 1) {
+        super(key, val);
+        this.count = count;
     }
 }
 /**
@@ -33,23 +27,23 @@ export class TreeMultiset extends AVLTree {
      * TreeMultiset.
      */
     constructor(options) {
-        super(Object.assign({}, options));
+        super(options);
         this._count = 0;
     }
     get count() {
         return this._count;
     }
     /**
-     * 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, val, count) {
-        return new TreeMultisetNode(id, val, count);
+    createNode(key, val, count) {
+        return new TreeMultisetNode(key, val, count);
     }
     /**
      * The function swaps the location of two nodes in a tree data structure.
@@ -59,15 +53,15 @@ export class TreeMultiset extends AVLTree {
      * @returns the `destNode` after swapping its values with the `srcNode`.
      */
     swapLocation(srcNode, destNode) {
-        const { id, val, count, height } = destNode;
-        const tempNode = this.createNode(id, val, count);
+        const { key, val, count, height } = destNode;
+        const tempNode = this.createNode(key, val, count);
         if (tempNode) {
             tempNode.height = height;
-            destNode.id = srcNode.id;
+            destNode.key = srcNode.key;
             destNode.val = srcNode.val;
             destNode.count = srcNode.count;
             destNode.height = srcNode.height;
-            srcNode.id = tempNode.id;
+            srcNode.key = tempNode.key;
             srcNode.val = tempNode.val;
             srcNode.count = tempNode.count;
             srcNode.height = tempNode.height;
@@ -77,24 +71,23 @@ export class TreeMultiset extends AVLTree {
     /**
      * 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, val, count) {
-        count = count !== null && count !== void 0 ? count : 1;
+    add(keyOrNode, val, count = 1) {
         let inserted = undefined, newNode;
-        if (idOrNode instanceof TreeMultisetNode) {
-            newNode = this.createNode(idOrNode.id, idOrNode.val, idOrNode.count);
+        if (keyOrNode instanceof TreeMultisetNode) {
+            newNode = this.createNode(keyOrNode.key, keyOrNode.val, keyOrNode.count);
         }
-        else if (idOrNode === null) {
+        else if (keyOrNode === null) {
             newNode = null;
         }
         else {
-            newNode = this.createNode(idOrNode, val, count);
+            newNode = this.createNode(keyOrNode, val, count);
         }
         if (!this.root) {
             this._setRoot(newNode);
@@ -108,14 +101,14 @@ export class TreeMultiset extends AVLTree {
             while (traversing) {
                 if (cur) {
                     if (newNode) {
-                        if (this._compare(cur.id, newNode.id) === CP.eq) {
+                        if (this._compare(cur.key, newNode.key) === CP.eq) {
                             cur.val = newNode.val;
                             cur.count += newNode.count;
                             this._setCount(this.count + newNode.count);
                             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) {
                                 //Add to the left of the current node
@@ -131,7 +124,7 @@ export class TreeMultiset extends AVLTree {
                                     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) {
                                 //Add to the right of the current node
@@ -199,26 +192,26 @@ export class TreeMultiset extends AVLTree {
     /**
      * 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)[]} keysOrNodes - 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, data) {
+    addMany(keysOrNodes, data) {
         const inserted = [];
-        for (let i = 0; i < idsOrNodes.length; i++) {
-            const idOrNode = idsOrNodes[i];
-            if (idOrNode instanceof TreeMultisetNode) {
-                inserted.push(this.add(idOrNode.id, idOrNode.val, idOrNode.count));
+        for (let i = 0; i < keysOrNodes.length; i++) {
+            const keyOrNode = keysOrNodes[i];
+            if (keyOrNode instanceof TreeMultisetNode) {
+                inserted.push(this.add(keyOrNode.key, keyOrNode.val, keyOrNode.count));
                 continue;
             }
-            if (idOrNode === null) {
+            if (keyOrNode === null) {
                 inserted.push(this.add(NaN, null, 0));
                 continue;
             }
-            inserted.push(this.add(idOrNode, data === null || data === void 0 ? void 0 : data[i], 1));
+            inserted.push(this.add(keyOrNode, data === null || data === void 0 ? void 0 : data[i], 1));
         }
         return inserted;
     }
@@ -228,7 +221,7 @@ export class TreeMultiset extends AVLTree {
      * @returns The function `perfectlyBalance()` returns a boolean value.
      */
     perfectlyBalance() {
-        const sorted = this.DFS('in', 'node'), n = sorted.length;
+        const sorted = this.dfs('in', 'node'), n = sorted.length;
         if (sorted.length < 1)
             return false;
         this.clear();
@@ -238,7 +231,7 @@ export class TreeMultiset extends AVLTree {
                     return;
                 const m = l + Math.floor((r - l) / 2);
                 const midNode = sorted[m];
-                this.add(midNode.id, midNode.val, midNode.count);
+                this.add(midNode.key, midNode.val, midNode.count);
                 buildBalanceBST(l, m - 1);
                 buildBalanceBST(m + 1, r);
             };
@@ -254,7 +247,7 @@ export class TreeMultiset extends AVLTree {
                     if (l <= r) {
                         const m = l + Math.floor((r - l) / 2);
                         const midNode = sorted[m];
-                        this.add(midNode.id, midNode.val, midNode.count);
+                        this.add(midNode.key, midNode.val, midNode.count);
                         stack.push([m + 1, r]);
                         stack.push([l, m - 1]);
                     }
@@ -266,17 +259,17 @@ export class TreeMultiset extends AVLTree {
     /**
      * 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, ignoreCount) {
+    remove(nodeOrKey, ignoreCount = false) {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
-        const curr = this.get(nodeOrId);
+        const curr = this.get(nodeOrKey);
         if (!curr)
             return bstDeletedResult;
         const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
@@ -364,14 +357,14 @@ export class TreeMultiset extends AVLTree {
     /**
      * 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) {
         if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot, 'id');
+            subTreeRoot = this.get(subTreeRoot, 'key');
         if (!subTreeRoot)
             return 0;
         let sum = 0;
@@ -397,8 +390,8 @@ export class TreeMultiset extends AVLTree {
     /**
      * 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.
@@ -406,7 +399,7 @@ export class TreeMultiset extends AVLTree {
      */
     subTreeAddCount(subTreeRoot, delta) {
         if (typeof subTreeRoot === 'number')
-            subTreeRoot = this.get(subTreeRoot, 'id');
+            subTreeRoot = this.get(subTreeRoot, 'key');
         if (!subTreeRoot)
             return false;
         const _addByProperty = (cur) => {
@@ -435,14 +428,14 @@ export class TreeMultiset extends AVLTree {
     /**
      * 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, onlyOne) {
+    getNodesByCount(nodeProperty, onlyOne = false) {
         if (!this.root)
             return [];
         const result = [];
@@ -480,10 +473,10 @@ export class TreeMultiset extends AVLTree {
     /**
      * 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
-     * BFS traversal.
+     * bfs traversal.
      */
     BFSCount() {
-        const nodes = super.BFS('node');
+        const nodes = super.bfs('node');
         return nodes.map(node => node.count);
     }
     /**
@@ -505,54 +498,51 @@ export class TreeMultiset extends AVLTree {
      * traversal pattern for the Morris traversal algorithm. It can have one of three values: 'in', 'pre', or 'post'.
      * @returns The function `morrisCount` returns an array of numbers.
      */
-    morrisCount(pattern) {
-        pattern = pattern || 'in';
+    morrisCount(pattern = 'in') {
         const nodes = super.morris(pattern, 'node');
         return nodes.map(node => node.count);
     }
     /**
-     * The function DFSIterativeCount performs an iterative depth-first search and returns an array of node counts based on
+     * The function dfsCountIterative performs an iterative depth-first search and returns an array of node counts based on
      * the specified traversal pattern.
      * @param {'in' | 'pre' | 'post'} [pattern] - The pattern parameter is a string that specifies the traversal order for
-     * the Depth-First Search (DFS) algorithm. It can have three possible values: 'in', 'pre', or 'post'.
-     * @returns The DFSIterativeCount function returns an array of numbers, which represents the count property of each node
-     * in the DFS traversal.
+     * the Depth-First Search (dfs) algorithm. It can have three possible values: 'in', 'pre', or 'post'.
+     * @returns The dfsCountIterative function returns an array of numbers, which represents the count property of each node
+     * in the dfs traversal.
      */
-    DFSIterativeCount(pattern) {
-        pattern = pattern !== null && pattern !== void 0 ? pattern : 'in';
-        const nodes = super.DFSIterative(pattern, 'node');
+    dfsCountIterative(pattern = 'in') {
+        const nodes = super.dfsIterative(pattern, 'node');
         return nodes.map(node => node.count);
     }
     /**
-     * The DFSCount function returns an array of counts for each node in a depth-first search traversal.
+     * The dfsCount function returns an array of counts for each node in a depth-first search traversal.
      * @param {DFSOrderPattern} [pattern] - The pattern parameter is an optional parameter that specifies the order in which
-     * the Depth-First Search (DFS) algorithm should traverse the nodes. It can have one of the following values:
-     * @returns The DFSCount function returns an array of numbers, specifically the count property of each node in the DFS
+     * the Depth-First Search (dfs) algorithm should traverse the nodes. It can have one of the following values:
+     * @returns The dfsCount function returns an array of numbers, specifically the count property of each node in the dfs
      * traversal.
      */
-    DFSCount(pattern) {
-        pattern = pattern !== null && pattern !== void 0 ? pattern : 'in';
-        const nodes = super.DFS(pattern, 'node');
+    dfsCount(pattern = 'in') {
+        const nodes = super.dfs(pattern, 'node');
         return nodes.map(node => node.count);
     }
     /**
      * 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) {
         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;
         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.subTreeSumCount(cur.right);
@@ -581,7 +571,7 @@ export class TreeMultiset extends AVLTree {
             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.subTreeSumCount(cur.right);
@@ -611,29 +601,29 @@ export class TreeMultiset extends AVLTree {
     /**
      * 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, delta) {
         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;
         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)
                     cur.count += delta;
                 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);
@@ -644,12 +634,12 @@ export class TreeMultiset extends AVLTree {
             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)
                         cur.count += delta;
-                    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);
                 }
             }