data-structure-typed 1.19.7 → 1.19.8

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

@@ -8,10 +8,12 @@
 
 import type {BinaryTreeNodeId, BinaryTreeNodeNested, BinaryTreeOptions} from '../types';
 import {AbstractBinaryTree, AbstractBinaryTreeNode} from './abstract-binary-tree';
-import {IBinaryTree, IBinaryTreeNode} from '../interfaces/binary-tree';
+import {IBinaryTree, IBinaryTreeNode} from '../interfaces';
 
 export class BinaryTreeNode<T = any, NEIGHBOR extends BinaryTreeNode<T, NEIGHBOR> = BinaryTreeNodeNested<T>> extends AbstractBinaryTreeNode<T, NEIGHBOR> implements IBinaryTreeNode<T, NEIGHBOR> {
-
+    constructor(id: BinaryTreeNodeId, val?: T) {
+        super(id, val);
+    }
 }
 
 export class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode> extends AbstractBinaryTree<N> implements IBinaryTree<N> {

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

@@ -11,7 +11,9 @@ import {BinaryTree, BinaryTreeNode} from './binary-tree';
 import {IBST, IBSTNode} from '../interfaces';
 
 export class BSTNode<T = any, NEIGHBOR extends BSTNode<T, NEIGHBOR> = BSTNodeNested<T>> extends BinaryTreeNode<T, NEIGHBOR> implements IBSTNode<T, NEIGHBOR> {
-
+    constructor(id: BinaryTreeNodeId, val?: T) {
+        super(id, val);
+    }
 }
 
 export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBST<N> {
@@ -51,6 +53,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
      * If the node was not added (e.g., due to a duplicate ID), it returns `null` or `undefined`.
      */
     override add(id: BinaryTreeNodeId, val?: N['val']): N | null | undefined {
+        // TODO support node as a param
         let inserted: N | null = null;
         const newNode = this.createNode(id, val);
         if (this.root === null) {

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

@@ -4,12 +4,12 @@ import {BST, BSTNode} from './bst';
 
 
 export class RBTreeNode<T = any, NEIGHBOR extends RBTreeNode<T, NEIGHBOR> = RBTreeNodeNested<T>> extends BSTNode<T, NEIGHBOR> implements IRBTreeNode<T, NEIGHBOR> {
-    constructor(id: BinaryTreeNodeId, color: RBColor, val?: T) {
+    constructor(id: BinaryTreeNodeId, val?: T, color: RBColor = RBColor.RED) {
         super(id, val);
         this._color = color;
     }
 
-    private _color: RBColor = RBColor.RED;
+    private _color: RBColor;
 
     get color(): RBColor {
         return this._color;
@@ -60,7 +60,7 @@ export class RBTree<N extends RBTreeNode<N['val'], N> = RBTreeNode> extends BST<
     }
 
     override createNode(id: BinaryTreeNodeId, val?: N['val']): N {
-        return new RBTreeNode(id, RBColor.RED, val) as N;
+        return new RBTreeNode(id, val, RBColor.RED) as N;
     }
 
     // private override _root: BinaryTreeNode<N> | null = null;

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

@@ -9,7 +9,6 @@ import type {BinaryTreeNodeId, TreeMultisetNodeNested, TreeMultisetOptions} from
 import {BinaryTreeDeletedResult, CP, DFSOrderPattern, FamilyPosition, LoopType, NodeOrPropertyName} from '../types';
 import {ITreeMultiset, ITreeMultisetNode} from '../interfaces';
 import {AVLTree, AVLTreeNode} from './avl-tree';
-import {ObjectWithNumberId} from '../../utils';
 
 export class TreeMultisetNode<T = any, NEIGHBOR extends TreeMultisetNode<T, NEIGHBOR> = TreeMultisetNodeNested<T>> extends AVLTreeNode<T, NEIGHBOR> implements ITreeMultisetNode<T, NEIGHBOR> {
 
@@ -28,7 +27,7 @@ export class TreeMultisetNode<T = any, NEIGHBOR extends TreeMultisetNode<T, NEIG
         this._count = count;
     }
 
-    private _count = 1;
+    private _count: number;
 
     get count(): number {
         return this._count;
@@ -51,7 +50,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
      * TreeMultiset.
      */
     constructor(options?: TreeMultisetOptions) {
-        super({...options, isMergeDuplicatedVal: true});
+        super({...options, isMergeDuplicatedNodeById: true});
     }
 
     private _count = 0;
@@ -81,95 +80,93 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
      * @returns the `destNode` after swapping its values with the `srcNode`.
      */
     override swapLocation(srcNode: N, destNode: N): N {
-        const {val, count, height, id} = destNode;
+        const {id, val, count, height} = destNode;
         const tempNode = this.createNode(id, val, count);
         if (tempNode) {
             tempNode.height = height;
 
-            if (tempNode instanceof TreeMultisetNode) {
-                destNode.id = srcNode.id;
-                destNode.val = srcNode.val;
-                destNode.count = srcNode.count;
-                destNode.height = srcNode.height;
+            destNode.id = srcNode.id;
+            destNode.val = srcNode.val;
+            destNode.count = srcNode.count;
+            destNode.height = srcNode.height;
 
-                srcNode.id = tempNode.id;
-                srcNode.val = tempNode.val;
-                srcNode.count = tempNode.count;
-                srcNode.height = tempNode.height;
-            }
+            srcNode.id = tempNode.id;
+            srcNode.val = tempNode.val;
+            srcNode.count = tempNode.count;
+            srcNode.height = tempNode.height;
         }
 
         return destNode;
     }
 
     /**
-     * The `add` function adds a new node to a binary tree, updating the size and count properties accordingly, and
-     * balancing the tree if necessary.
-     * @param {BinaryTreeNodeId} id - The id parameter represents the identifier of the binary tree node that we want to
-     * add. It is of type BinaryTreeNodeId.
-     * @param [val] - The `val` parameter is an optional value that can be assigned to the node being added. If no value is
-     * provided, it will default to `undefined`.
-     * @param {number} [count] - The `count` parameter is an optional parameter that specifies the number of times the node
-     * with the given `id` should be added to the binary tree. If the `count` parameter is not provided, it defaults to 1.
-     * @returns The `add` method returns the inserted node (`N`), `null`, or `undefined`.
+     * 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
+     * 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`.
      */
-    override add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null | undefined {
+    override add(idOrNode: BinaryTreeNodeId | N | null, val?: N['val'], count?: number): N | null | undefined {
         count = count ?? 1;
-        let inserted: N | null = null;
-        const newNode = this.createNode(id, val, count);
-        if (this.root === null) {
+        let inserted: N | null | undefined = undefined, newNode: N | null;
+        if (idOrNode instanceof TreeMultisetNode) {
+            newNode = this.createNode(idOrNode.id, idOrNode.val, idOrNode.count);
+        } else if (idOrNode === null) {
+            newNode = null;
+        } else {
+            newNode = this.createNode(idOrNode, val, count);
+        }
+        if (!this.root) {
             this._setRoot(newNode);
             this._setSize(this.size + 1);
-            this._setCount(this.count + count);
-            inserted = (this.root);
+            newNode && this._setCount(this.count + newNode.count);
+            inserted = this.root;
         } else {
             let cur = this.root;
             let traversing = true;
             while (traversing) {
-                if (cur !== null && newNode !== null) {
-                    if (this._compare(cur.id, id) === CP.eq) {
-                        if (newNode) {
+                if (cur) {
+                    if (newNode) {
+                        if (this._compare(cur.id, newNode.id) === CP.eq) {
                             cur.val = newNode.val;
-                            cur.count += count;
+                            cur.count += newNode.count;
                             this._setCount(this.count + newNode.count);
-                        }
-                        //Duplicates are not accepted.
-                        traversing = false;
-                        inserted = cur;
-                    } else if (this._compare(cur.id, id) === CP.gt) {
-                        // Traverse left of the node
-                        if (cur.left === undefined) {
-                            if (newNode) {
-                                newNode.parent = cur;
-                            }
-                            //Add to the left of the current node
-                            cur.left = newNode;
-                            this._setSize(this.size + 1);
-                            this._setCount(this.count + newNode.count);
-
                             traversing = false;
-                            inserted = cur.left;
-                        } else {
-                            //Traverse the left of the current node
-                            if (cur.left) cur = cur.left;
-                        }
-                    } else if (this._compare(cur.id, id) === CP.lt) {
-                        // Traverse right of the node
-                        if (cur.right === undefined) {
-                            if (newNode) {
-                                newNode.parent = cur;
+                            inserted = cur;
+                        } else if (this._compare(cur.id, newNode.id) === CP.gt) {
+                            // Traverse left of the node
+                            if (cur.left === undefined) {
+                                //Add to the left of the current node
+                                cur.left = newNode;
+                                this._setSize(this.size + 1);
+                                this._setCount(this.count + newNode.count);
+
+                                traversing = false;
+                                inserted = cur.left;
+                            } else {
+                                //Traverse the left of the current node
+                                if (cur.left) cur = cur.left;
+                            }
+                        } else if (this._compare(cur.id, newNode.id) === CP.lt) {
+                            // Traverse right of the node
+                            if (cur.right === undefined) {
+                                //Add to the right of the current node
+                                cur.right = newNode;
+                                this._setSize(this.size + 1);
+                                this._setCount(this.count + newNode.count);
+
+                                traversing = false;
+                                inserted = (cur.right);
+                            } else {
+                                //Traverse the left of the current node
+                                if (cur.right) cur = cur.right;
                             }
-                            //Add to the right of the current node
-                            cur.right = newNode;
-                            this._setSize(this.size + 1);
-                            this._setCount(this.count + newNode.count);
-
-                            traversing = false;
-                            inserted = (cur.right);
-                        } else {
-                            //Traverse the left of the current node
-                            if (cur.right) cur = cur.right;
                         }
+                    } else {
+                        // TODO may need to support null inserted
                     }
                 } else {
                     traversing = false;
@@ -192,24 +189,19 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
     override addTo(newNode: N | null, parent: N): N | null | undefined {
         if (parent) {
             if (parent.left === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                }
                 parent.left = newNode;
                 if (newNode !== null) {
                     this._setSize(this.size + 1);
-                    this._setCount(this.count + newNode.count ?? 0)
+                    this._setCount(this.count + newNode.count)
                 }
 
                 return parent.left;
             } else if (parent.right === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                }
+
                 parent.right = newNode;
                 if (newNode !== null) {
                     this._setSize(this.size + 1);
-                    this._setCount(this.count + newNode.count ?? 0);
+                    this._setCount(this.count + newNode.count);
                 }
                 return parent.right;
             } else {
@@ -221,66 +213,88 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
     }
 
     /**
-     * The `addMany` function inserts multiple items into a binary tree and returns an array of the inserted nodes or
-     * null/undefined values.
-     * @param {N[] | N[]} data - The `data` parameter can be either an array of elements of type `N` or an
-     * array of `N` objects.
+     * The `addMany` function adds multiple nodes to a binary tree and returns an array of the inserted nodes.
+     * @param {BinaryTreeNodeId[] | N[]} idsOrNodes - An array of BinaryTreeNodeId objects or N objects. These objects
+     * represent the IDs or nodes of the binary tree where the values will be added.
+     * @param {N['val'][]} [data] - Optional array of values to be associated with each node being added. If provided, the
+     * length of the `data` array should be equal to the length of the `idsOrNodes` array.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    override addMany(data: N[] | Array<N['val']>): (N | null | undefined)[] {
+    override addMany(idsOrNodes: (BinaryTreeNodeId | N)[], data?: N['val'][]): (N | null | undefined)[] {
         // TODO not sure addMany not be run multi times
         const inserted: (N | null | undefined)[] = [];
-        const map: Map<N | N['val'], number> = new Map();
+        const map: Map<N | BinaryTreeNodeId, number> = new Map();
 
-        if (this.isMergeDuplicatedVal) {
-            for (const nodeOrId of data) map.set(nodeOrId, (map.get(nodeOrId) ?? 0) + 1);
+        if (this.isMergeDuplicatedNodeById) {
+            for (const idOrNode of idsOrNodes) map.set(idOrNode, (map.get(idOrNode) ?? 0) + 1);
         }
 
-        for (const nodeOrId of data) {
-
-            if (nodeOrId instanceof TreeMultisetNode) {
-                inserted.push(this.add(nodeOrId.id, nodeOrId.val, nodeOrId.count));
+        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));
                 continue;
             }
 
-            if (nodeOrId === null) {
+            if (idOrNode === null) {
                 inserted.push(this.add(NaN, null, 0));
                 continue;
             }
 
-            // TODO will this cause an issue?
-            const count = this.isMergeDuplicatedVal ? map.get(nodeOrId) : 1;
-            let newId: BinaryTreeNodeId;
-            if (typeof nodeOrId === 'number') {
-                newId = this.autoIncrementId ? this.maxId + 1 : nodeOrId;
-            } else if (nodeOrId instanceof Object) {
-                if (this.autoIncrementId) {
-                    newId = this.maxId + 1;
-                } else {
-                    if (Object.keys(nodeOrId).includes('id')) {
-                        newId = (nodeOrId as ObjectWithNumberId).id;
-                    } else {
-                        console.warn(nodeOrId, 'Object value must has an id property when the autoIncrementId is false');
-                        continue;
-                    }
+            const count = this.isMergeDuplicatedNodeById ? map.get(idOrNode) : 1;
+            const val = data?.[i];
+            if (this.isMergeDuplicatedNodeById) {
+                if (map.has(idOrNode)) {
+                    inserted.push(this.add(idOrNode, val, count));
+                    map.delete(idOrNode);
                 }
             } else {
-                console.warn(nodeOrId, ` is not added`);
-                continue;
+                inserted.push(this.add(idOrNode, val, 1));
             }
+        }
+        return inserted;
+    }
+
+    /**
+     * 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.
+     * @returns The function `perfectlyBalance()` returns a boolean value.
+     */
+    override perfectlyBalance(): boolean {
+        const sorted = this.DFS('in', 'node'), n = sorted.length;
+        if (sorted.length < 1) return false;
+
+        this.clear();
+
+        if (this.loopType === LoopType.RECURSIVE) {
+            const buildBalanceBST = (l: number, r: number) => {
+                if (l > r) return;
+                const m = l + Math.floor((r - l) / 2);
+                const midNode = sorted[m];
+                this.add(midNode.id, midNode.val, midNode.count);
+                buildBalanceBST(l, m - 1);
+                buildBalanceBST(m + 1, r);
+            };
 
-            if (this.isMergeDuplicatedVal) {
-                if (map.has(nodeOrId)) {
-                    inserted.push(this.add(newId, nodeOrId, count));
-                    map.delete(nodeOrId);
+            buildBalanceBST(0, n - 1);
+            return true;
+        } else {
+            const stack: [[number, number]] = [[0, n - 1]];
+            while (stack.length > 0) {
+                const popped = stack.pop();
+                if (popped) {
+                    const [l, r] = popped;
+                    if (l <= r) {
+                        const m = l + Math.floor((r - l) / 2);
+                        const midNode = sorted[m];
+                        this.add(midNode.id, midNode.val, midNode.count);
+                        stack.push([m + 1, r]);
+                        stack.push([l, m - 1]);
+                    }
                 }
-            } else {
-                inserted.push(this.add(newId, nodeOrId, 1));
             }
-
-            this._setMaxId(newId);
+            return true;
         }
-        return inserted;
     }
 
     /**
@@ -296,7 +310,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
         const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];
         if (!this.root) return bstDeletedResult;
 
-        const curr: N | null = (typeof nodeOrId === 'number') ? this.get(nodeOrId) : nodeOrId;
+        const curr: N | null = this.get(nodeOrId);
         if (!curr) return bstDeletedResult;
 
         const parent: N | null = curr?.parent ? curr.parent : null;
@@ -324,13 +338,17 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
                     const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
                     orgCurrent = this.swapLocation(curr, leftSubTreeRightMost);
                     if (parentOfLeftSubTreeMax) {
-                        if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
-                        else parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
+                        if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) {
+                            parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
+                        } else {
+                            parentOfLeftSubTreeMax.left = leftSubTreeRightMost.left;
+                        }
                         needBalanced = parentOfLeftSubTreeMax;
                     }
                 }
             }
             this._setSize(this.size - 1);
+            // TODO How to handle when the count of target node is lesser than current node's count
             this._setCount(this.count - orgCurrent.count);
         }
 

package/src/data-structures/graph/abstract-graph.ts

@@ -170,6 +170,7 @@ export abstract class AbstractGraph<V extends AbstractVertex<any>, E extends Abs
     addVertex(idOrVertex: VertexId | V, val?: V['val']): boolean {
         if (idOrVertex instanceof AbstractVertex) {
             return this._addVertexOnly(idOrVertex);
+
         } else {
             const newVertex = this.createVertex(idOrVertex, val);
             return this._addVertexOnly(newVertex);

package/src/data-structures/heap/heap.ts

@@ -44,9 +44,9 @@ export class HeapItem<T = number> {
 }
 
 export abstract class Heap<T = number> {
-
     /**
-     * The constructor function initializes a priority queue with an optional priority extractor function.
+     * The function is a constructor for a class that initializes a priority callback function based on the
+     * options provided.
      * @param [options] - An optional object that contains configuration options for the Heap.
      */
     protected constructor(options?: HeapOptions<T>) {
@@ -91,16 +91,9 @@ export abstract class Heap<T = number> {
     peek(isItem?: undefined): T | undefined;
     peek(isItem: false): T | undefined;
     peek(isItem: true): HeapItem<T> | null;
-
     /**
-     * The `peek` function returns the top item or value in a priority queue, depending on the value of the `isItem`
-     * parameter.
-     * @param {boolean} [isItem] - The `isItem` parameter is an optional boolean parameter that determines whether the
-     * method should return the entire `HeapItem` object or just the value of the item. If `isItem` is set to `true`, the
-     * method will return the `HeapItem` object. If `isItem`
-     * @returns The `peek` method returns either a `HeapItem<T>` object, `null`, `T`, or `undefined`. The specific return
-     * type depends on the value of the `isItem` parameter. If `isItem` is `true`, then the method returns a `HeapItem<T>`
-     * object or `null` if the heap is empty. If `isItem` is `false`
+     * The `peek` function returns the top item in the priority queue without removing it.
+     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an val with the highest priority in the queue
      */
     peek(isItem?: boolean): HeapItem<T> | null | T | undefined {
         isItem = isItem ?? false;
@@ -111,16 +104,9 @@ export abstract class Heap<T = number> {
     peekLast(isItem?: undefined): T | undefined;
     peekLast(isItem: false): T | undefined;
     peekLast(isItem: true): HeapItem<T> | null;
-
     /**
-     * The `peekLast` function returns the last item in the heap, either as a `HeapItem` object or just the value depending
-     * on the `isItem` parameter.
-     * @param {boolean} [isItem] - A boolean parameter that indicates whether the method should return the HeapItem object
-     * or just the value of the last item in the heap. If isItem is true, the method will return the HeapItem object. If
-     * isItem is false or not provided, the method will return the value of the last item
-     * @returns The method `peekLast` returns either a `HeapItem<T>` object, `null`, `T`, or `undefined`. The specific
-     * return type depends on the value of the `isItem` parameter. If `isItem` is `true`, then the method returns a
-     * `HeapItem<T>` object or `null` if there are no items in the heap. If `isItem`
+     * The `peekLast` function returns the last item in the heap.
+     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an val with the lowest priority in the queue
      */
     peekLast(isItem?: boolean): HeapItem<T> | null | T | undefined {
         isItem = isItem ?? false;
@@ -147,15 +133,9 @@ export abstract class Heap<T = number> {
     poll(isItem?: undefined): T | undefined;
     poll(isItem: false): T | undefined;
     poll(isItem: true): HeapItem<T> | null;
-
     /**
-     * The `poll` function returns the top item from a priority queue, either as a HeapItem object or its value, depending
-     * on the value of the `isItem` parameter.
-     * @param {boolean} [isItem] - The `isItem` parameter is a boolean flag that indicates whether the returned value
-     * should be a `HeapItem<T>` object or just the value `T` itself. If `isItem` is `true`, the method will return the
-     * `HeapItem<T>` object, otherwise it will return just
-     * @returns The function `poll` returns either a `HeapItem<T>` object, `null`, or `T` (the value of the `val` property
-     * of the `HeapItem<T>` object).
+     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an val with the highest priority in the queue
+     * @returns either a HeapItem<T> object or null.
      */
     poll(isItem?: boolean): HeapItem<T> | null | T | undefined {
         isItem = isItem ?? false;
@@ -167,8 +147,8 @@ export abstract class Heap<T = number> {
     }
 
     /**
-     * The `has` function checks if a given node or value exists in the priority queue.
-     * @param {T | HeapItem<T>} node - The `node` parameter can be of type `T` or `HeapItem<T>`.
+     * The function checks if a given node or value exists in the priority queue.
+     * @param {T | HeapItem<T>} node - The parameter `node` can be of type `T` or `HeapItem<T>`.
      * @returns a boolean value.
      */
     has(node: T | HeapItem<T>): boolean {
@@ -184,15 +164,9 @@ export abstract class Heap<T = number> {
     toArray(isItem?: undefined): (T | undefined)[];
     toArray(isItem: false): (T | undefined)[];
     toArray(isItem: true): (HeapItem<T> | null)[];
-
     /**
-     * The `toArray` function returns an array of either HeapItem objects or their values, depending on the value of the
-     * `isItem` parameter.
-     * @param {boolean} [isItem] - isItem is an optional boolean parameter that determines whether the returned array
-     * should contain the HeapItem objects or just the values of the HeapItem objects. If isItem is true, the array will
-     * contain the HeapItem objects. If isItem is false or not provided, the array will contain only the values
-     * @returns The method `toArray` returns an array of `HeapItem<T>` objects, or an array of `T` values if the `isItem`
-     * parameter is set to `false`.
+     * The `toArray` function returns an array of `HeapItem<T>` objects.
+     * @returns An array of HeapItem<T> objects.Returns a sorted list of vals
      */
     toArray(isItem?: boolean): (HeapItem<T> | null | T | undefined)[] {
         isItem = isItem ?? false;

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

@@ -51,15 +51,9 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
 
     get visitedNode(): N[]
 
-    get visitedCount(): number[]
-
     get visitedLeftSum(): number[]
 
-    get autoIncrementId(): boolean
-
-    get maxId(): number
-
-    get isMergeDuplicatedVal(): boolean
+    get isMergeDuplicatedNodeById(): boolean
 
     get root(): N | null
 
@@ -71,13 +65,13 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
 
     isEmpty(): boolean
 
-    add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null | undefined
+    add(id: BinaryTreeNodeId | N, val?: N['val']): N | null | undefined
 
     addTo(newNode: N | null, parent: N): N | null | undefined
 
-    addMany(data: N[] | Array<N['val']>): (N | null | undefined)[]
+    addMany(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N['val'][]): (N | null | undefined)[]
 
-    fill(data: N[] | Array<N['val']>): boolean
+    fill(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N[] | Array<N['val']>): boolean
 
     remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[]
 
@@ -109,9 +103,9 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
 
     getRightMost(node?: N | null): N | null
 
-    isBSTByRooted(node: N | null): boolean
+    isSubtreeBST(node: N | null): boolean
 
-    isBST(node?: N | null): boolean
+    isBST(): boolean
 
     getSubTreeSize(subTreeRoot: N | null | undefined): number
 
@@ -195,37 +189,6 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
 
     morris(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>
 
-    // _setLoopType(value: LoopType): void
-    //
-    // _setVisitedId(value: BinaryTreeNodeId[]): void
-    //
-    // _setVisitedVal(value: Array<N>): void
-    //
-    // _setVisitedNode(value: N[]): void
-    //
-    // setVisitedCount(value: number[]): void
-    //
-    // _setVisitedLeftSum(value: number[]): void
-    //
-    // _setAutoIncrementId(value: boolean): void
-    //
-    // _setMaxId(value: number): void
-    //
-    // _setIsDuplicatedVal(value: boolean): void
-    //
-    // _setRoot(v: N | null): void
-    //
-    // _setSize(v: number): void
-    //
-    // _setCount(v: number): void
-    //
-    // _resetResults(): void
-
-    // _pushByPropertyNameStopOrNot(cur: N, result: (N | null | undefined)[], nodeProperty: BinaryTreeNodeId | N, propertyName ?: BinaryTreeNodePropertyName, onlyOne ?: boolean): void
-    //
-    // _accumulatedByPropertyName(node: N, nodeOrPropertyName ?: NodeOrPropertyName): void
-    //
-    // _getResultByPropertyName(nodeOrPropertyName ?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>
 
     // --- end additional methods ---
 }

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

@@ -37,6 +37,5 @@ export type AbstractBinaryTreeNodeNested<T> = AbstractBinaryTreeNode<T, Abstract
 
 export type AbstractBinaryTreeOptions = {
     loopType?: LoopType,
-    autoIncrementId?: boolean,
-    isMergeDuplicatedVal?: boolean
+    isMergeDuplicatedNodeById?: boolean
 }

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

@@ -3,6 +3,6 @@ import {AVLTreeOptions} from './avl-tree';
 
 export type TreeMultisetNodeNested<T> = TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, TreeMultisetNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
 
-export type TreeMultisetOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedVal'> & {
-    isMergeDuplicatedVal: true,
+export type TreeMultisetOptions = Omit<AVLTreeOptions, 'isMergeDuplicatedNodeById'> & {
+    isMergeDuplicatedNodeById: true,
 }