data-structure-typed 1.19.6 → 1.19.8

package/dist/data-structures/binary-tree/avl-tree.js

@@ -10,6 +10,9 @@ exports.AVLTree = exports.AVLTreeNode = void 0;
  */
 const bst_1 = require("./bst");
 class AVLTreeNode extends bst_1.BSTNode {
+    constructor(id, val) {
+        super(id, val);
+    }
 }
 exports.AVLTreeNode = AVLTreeNode;
 class AVLTree extends bst_1.BST {
@@ -41,6 +44,7 @@ class AVLTree extends bst_1.BST {
      * @returns The method is returning the inserted node, or null or undefined if the insertion was not successful.
      */
     add(id, val) {
+        // TODO support node as a param
         const inserted = super.add(id, val);
         if (inserted)
             this.balancePath(inserted);

package/dist/data-structures/binary-tree/binary-tree.d.ts

@@ -7,8 +7,9 @@
  */
 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 declare class BinaryTreeNode<T = any, NEIGHBOR extends BinaryTreeNode<T, NEIGHBOR> = BinaryTreeNodeNested<T>> extends AbstractBinaryTreeNode<T, NEIGHBOR> implements IBinaryTreeNode<T, NEIGHBOR> {
+    constructor(id: BinaryTreeNodeId, val?: T);
 }
 export declare class BinaryTree<N extends BinaryTreeNode<N['val'], N> = BinaryTreeNode> extends AbstractBinaryTree<N> implements IBinaryTree<N> {
     /**

package/dist/data-structures/binary-tree/binary-tree.js

@@ -10,6 +10,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BinaryTree = exports.BinaryTreeNode = void 0;
 const abstract_binary_tree_1 = require("./abstract-binary-tree");
 class BinaryTreeNode extends abstract_binary_tree_1.AbstractBinaryTreeNode {
+    constructor(id, val) {
+        super(id, val);
+    }
 }
 exports.BinaryTreeNode = BinaryTreeNode;
 class BinaryTree extends abstract_binary_tree_1.AbstractBinaryTree {

package/dist/data-structures/binary-tree/bst.d.ts

@@ -10,6 +10,7 @@ import { CP } from '../types';
 import { BinaryTree, BinaryTreeNode } from './binary-tree';
 import { IBST, IBSTNode } from '../interfaces';
 export declare class BSTNode<T = any, NEIGHBOR extends BSTNode<T, NEIGHBOR> = BSTNodeNested<T>> extends BinaryTreeNode<T, NEIGHBOR> implements IBSTNode<T, NEIGHBOR> {
+    constructor(id: BinaryTreeNodeId, val?: T);
 }
 export declare class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N> implements IBST<N> {
     /**

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

@@ -4,6 +4,9 @@ exports.BST = exports.BSTNode = void 0;
 const types_1 = require("../types");
 const binary_tree_1 = require("./binary-tree");
 class BSTNode extends binary_tree_1.BinaryTreeNode {
+    constructor(id, val) {
+        super(id, val);
+    }
 }
 exports.BSTNode = BSTNode;
 class BST extends binary_tree_1.BinaryTree {
@@ -42,6 +45,7 @@ class BST extends binary_tree_1.BinaryTree {
      * If the node was not added (e.g., due to a duplicate ID), it returns `null` or `undefined`.
      */
     add(id, val) {
+        // TODO support node as a param
         let inserted = null;
         const newNode = this.createNode(id, val);
         if (this.root === null) {

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

@@ -2,7 +2,7 @@ import { BinaryTreeNodeId, RBColor, RBTreeNodeNested, RBTreeOptions } from '../t
 import { IRBTree, IRBTreeNode } from '../interfaces/rb-tree';
 import { BST, BSTNode } from './bst';
 export declare 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);
     private _color;
     get color(): RBColor;
     set color(value: RBColor);

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

@@ -4,9 +4,8 @@ exports.RBTree = exports.RBTreeNode = void 0;
 const types_1 = require("../types");
 const bst_1 = require("./bst");
 class RBTreeNode extends bst_1.BSTNode {
-    constructor(id, color, val) {
+    constructor(id, val, color = types_1.RBColor.RED) {
         super(id, val);
-        this._color = types_1.RBColor.RED;
         this._color = color;
     }
     get color() {
@@ -22,7 +21,7 @@ class RBTree extends bst_1.BST {
         super(options);
     }
     createNode(id, val) {
-        return new RBTreeNode(id, types_1.RBColor.RED, val);
+        return new RBTreeNode(id, val, types_1.RBColor.RED);
     }
     // private override _root: BinaryTreeNode<N> | null = null;
     //

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

@@ -57,17 +57,16 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      */
     swapLocation(srcNode: N, destNode: N): N;
     /**
-     * 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`.
-     */
-    add(id: BinaryTreeNodeId, val?: N['val'], count?: number): N | null | 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`.
+     */
+    add(idOrNode: BinaryTreeNodeId | N | null, val?: N['val'], count?: number): N | null | undefined;
     /**
      * The function adds a new node to a binary tree as the left or right child of a given parent node.
      * @param {N | null} newNode - The `newNode` parameter represents the node that you want to add to the tree. It can be
@@ -79,13 +78,20 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
      */
     addTo(newNode: N | null, parent: N): N | null | undefined;
     /**
-     * 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.
      */
-    addMany(data: N[] | Array<N['val']>): (N | null | undefined)[];
+    addMany(idsOrNodes: (BinaryTreeNodeId | N)[], 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.
+     * @returns The function `perfectlyBalance()` returns a boolean value.
+     */
+    perfectlyBalance(): boolean;
     /**
      * 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.

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

@@ -16,7 +16,6 @@ class TreeMultisetNode extends avl_tree_1.AVLTreeNode {
      */
     constructor(id, val, count = 1) {
         super(id, val);
-        this._count = 1;
         this._count = count;
     }
     get count() {
@@ -38,7 +37,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * TreeMultiset.
      */
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { isMergeDuplicatedVal: true }));
+        super(Object.assign(Object.assign({}, options), { isMergeDuplicatedNodeById: true }));
         this._count = 0;
     }
     get count() {
@@ -64,97 +63,98 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * @returns the `destNode` after swapping its values with the `srcNode`.
      */
     swapLocation(srcNode, destNode) {
-        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;
-                srcNode.id = tempNode.id;
-                srcNode.val = tempNode.val;
-                srcNode.count = tempNode.count;
-                srcNode.height = tempNode.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;
         }
         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`.
      */
-    add(id, val, count) {
+    add(idOrNode, val, count) {
         count = count !== null && count !== void 0 ? count : 1;
-        let inserted = null;
-        const newNode = this.createNode(id, val, count);
-        if (this.root === null) {
+        let inserted = undefined, newNode;
+        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) === types_1.CP.eq) {
-                        if (newNode) {
+                if (cur) {
+                    if (newNode) {
+                        if (this._compare(cur.id, newNode.id) === types_1.CP.eq) {
                             cur.val = newNode.val;
-                            cur.count += count;
-                            this._setCount(this.count + newNode.count);
-                        }
-                        //Duplicates are not accepted.
-                        traversing = false;
-                        inserted = cur;
-                    }
-                    else if (this._compare(cur.id, id) === types_1.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);
+                            cur.count += newNode.count;
                             this._setCount(this.count + newNode.count);
                             traversing = false;
-                            inserted = cur.left;
+                            inserted = cur;
                         }
-                        else {
-                            //Traverse the left of the current node
-                            if (cur.left)
-                                cur = cur.left;
-                        }
-                    }
-                    else if (this._compare(cur.id, id) === types_1.CP.lt) {
-                        // Traverse right of the node
-                        if (cur.right === undefined) {
-                            if (newNode) {
-                                newNode.parent = cur;
+                        else if (this._compare(cur.id, newNode.id) === types_1.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;
                             }
-                            //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 if (this._compare(cur.id, newNode.id) === types_1.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;
+                            }
                         }
                     }
+                    else {
+                        // TODO may need to support null inserted
+                    }
                 }
                 else {
                     traversing = false;
@@ -175,27 +175,20 @@ class TreeMultiset extends avl_tree_1.AVLTree {
      * `undefined` in certain cases.
      */
     addTo(newNode, parent) {
-        var _a, _b;
         if (parent) {
             if (parent.left === undefined) {
-                if (newNode) {
-                    newNode.parent = parent;
-                }
                 parent.left = newNode;
                 if (newNode !== null) {
                     this._setSize(this.size + 1);
-                    this._setCount((_a = this.count + newNode.count) !== null && _a !== void 0 ? _a : 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((_b = this.count + newNode.count) !== null && _b !== void 0 ? _b : 0);
+                    this._setCount(this.count + newNode.count);
                 }
                 return parent.right;
             }
@@ -208,66 +201,86 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         }
     }
     /**
-     * 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.
      */
-    addMany(data) {
+    addMany(idsOrNodes, data) {
         var _a;
         // TODO not sure addMany not be run multi times
         const inserted = [];
         const map = new Map();
-        if (this.isMergeDuplicatedVal) {
-            for (const nodeOrId of data)
-                map.set(nodeOrId, ((_a = map.get(nodeOrId)) !== null && _a !== void 0 ? _a : 0) + 1);
+        if (this.isMergeDuplicatedNodeById) {
+            for (const idOrNode of idsOrNodes)
+                map.set(idOrNode, ((_a = map.get(idOrNode)) !== null && _a !== void 0 ? _a : 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;
-            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.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 === null || data === void 0 ? void 0 : 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));
             }
-            if (this.isMergeDuplicatedVal) {
-                if (map.has(nodeOrId)) {
-                    inserted.push(this.add(newId, nodeOrId, count));
-                    map.delete(nodeOrId);
+        }
+        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.
+     */
+    perfectlyBalance() {
+        const sorted = this.DFS('in', 'node'), n = sorted.length;
+        if (sorted.length < 1)
+            return false;
+        this.clear();
+        if (this.loopType === types_1.LoopType.RECURSIVE) {
+            const buildBalanceBST = (l, r) => {
+                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);
+            };
+            buildBalanceBST(0, n - 1);
+            return true;
+        }
+        else {
+            const stack = [[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;
     }
     /**
      * The `remove` function removes a node from a binary search tree and returns the deleted node along with the parent
@@ -282,7 +295,7 @@ class TreeMultiset extends avl_tree_1.AVLTree {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
-        const curr = (typeof nodeOrId === 'number') ? this.get(nodeOrId) : nodeOrId;
+        const curr = this.get(nodeOrId);
         if (!curr)
             return bstDeletedResult;
         const parent = (curr === null || curr === void 0 ? void 0 : curr.parent) ? curr.parent : null;
@@ -314,15 +327,18 @@ class TreeMultiset extends avl_tree_1.AVLTree {
                     const parentOfLeftSubTreeMax = leftSubTreeRightMost.parent;
                     orgCurrent = this.swapLocation(curr, leftSubTreeRightMost);
                     if (parentOfLeftSubTreeMax) {
-                        if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost)
+                        if (parentOfLeftSubTreeMax.right === leftSubTreeRightMost) {
                             parentOfLeftSubTreeMax.right = leftSubTreeRightMost.left;
-                        else
+                        }
+                        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);
         }
         bstDeletedResult.push({ deleted: orgCurrent, needBalanced });

package/dist/data-structures/interfaces/abstract-binary-tree.d.ts

@@ -21,20 +21,17 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
     get visitedId(): BinaryTreeNodeId[];
     get visitedVal(): Array<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;
     get size(): number;
     swapLocation(srcNode: N, destNode: N): N;
     clear(): void;
     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)[];
-    fill(data: N[] | Array<N['val']>): boolean;
+    addMany(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N['val'][]): (N | null | undefined)[];
+    fill(idsOrNodes: (BinaryTreeNodeId | N | null)[], data?: N[] | Array<N['val']>): boolean;
     remove(id: BinaryTreeNodeId, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
     getDepth(node: N): number;
     getHeight(beginRoot?: N | null): number;
@@ -50,8 +47,8 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
     getRightMost(): N | null;
     getRightMost(node: N): N;
     getRightMost(node?: N | null): N | null;
-    isBSTByRooted(node: N | null): boolean;
-    isBST(node?: N | null): boolean;
+    isSubtreeBST(node: N | null): boolean;
+    isBST(): boolean;
     getSubTreeSize(subTreeRoot: N | null | undefined): number;
     subTreeSum(subTreeRoot: N, propertyName?: BinaryTreeNodePropertyName): number;
     subTreeAdd(subTreeRoot: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;

package/dist/data-structures/types/abstract-binary-tree.d.ts

@@ -31,6 +31,5 @@ export type AbstractBinaryTreeNodeProperties<N extends AbstractBinaryTreeNode<N[
 export type AbstractBinaryTreeNodeNested<T> = AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, AbstractBinaryTreeNode<T, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type AbstractBinaryTreeOptions = {
     loopType?: LoopType;
-    autoIncrementId?: boolean;
-    isMergeDuplicatedVal?: boolean;
+    isMergeDuplicatedNodeById?: boolean;
 };

package/dist/data-structures/types/tree-multiset.d.ts

@@ -1,6 +1,6 @@
 import { TreeMultisetNode } from '../binary-tree';
 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;
 };

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "data-structure-typed",
-  "version": "1.19.6",
+  "version": "1.19.8",
   "description": "Javascript & TypeScript Data Structure Library, meticulously crafted to empower developers with a versatile set of essential data structures. Our library includes a wide range of data structures, such as Binary Tree, AVL Tree, Binary Search Tree (BST), Tree Multiset, Segment Tree, Binary Indexed Tree, Graph, Directed Graph, Undirected Graph, Singly Linked List, Hash, CoordinateSet, CoordinateMap, Heap, Doubly Linked List, Priority Queue, Max Priority Queue, Min Priority Queue, Queue, ObjectDeque, ArrayDeque, Stack, and Trie. Each data structure is thoughtfully designed and implemented using TypeScript to provide efficient, reliable, and easy-to-use solutions for your programming needs. Whether you're optimizing algorithms, managing data, or enhancing performance, our TypeScript Data Structure Library is your go-to resource. Elevate your coding experience with these fundamental building blocks for software development.",
   "main": "dist/index.js",
   "scripts": {
     "build": "rm -rf dist && npx tsc",
     "test": "jest",
+    "update:test-deps": "npm i avl-tree-typed binary-tree-typed bst-typed deque-typed directed-graph-typed doubly-linked-list-typed graph-typed heap-typed linked-list-typed max-heap-typed max-priority-queue-typed min-heap-typed min-priority-queue-typed priority-queue-typed singly-linked-list-typed stack-typed tree-multiset-typed trie-typed undirected-graph-typed --save-dev",
     "build:docs": "typedoc --out docs ./src",
     "deps:check": "dependency-cruiser src",
     "build:publish": "npm run test && npm run build && npm run build:docs && npm publish"
@@ -58,16 +59,32 @@
   "devDependencies": {
     "@types/jest": "^29.5.3",
     "@types/node": "^20.4.9",
+    "avl-tree-typed": "^1.19.7",
+    "binary-tree-typed": "^1.19.7",
+    "bst-typed": "^1.19.7",
     "dependency-cruiser": "^13.1.2",
+    "deque-typed": "^1.19.7",
+    "directed-graph-typed": "^1.19.7",
+    "doubly-linked-list-typed": "^1.19.7",
+    "graph-typed": "^1.19.7",
+    "heap-typed": "^1.19.7",
     "jest": "^29.6.2",
+    "linked-list-typed": "^1.19.7",
+    "max-heap-typed": "^1.19.7",
+    "max-priority-queue-typed": "^1.19.7",
+    "min-heap-typed": "^1.19.7",
+    "min-priority-queue-typed": "^1.19.7",
+    "priority-queue-typed": "^1.19.7",
+    "singly-linked-list-typed": "^1.19.7",
+    "stack-typed": "^1.19.7",
+    "tree-multiset-typed": "^1.19.7",
+    "trie-typed": "^1.19.7",
     "ts-jest": "^29.1.1",
     "typedoc": "^0.24.8",
-    "typescript": "^4.9.5"
+    "typescript": "^4.9.5",
+    "undirected-graph-typed": "^1.19.7"
   },
   "dependencies": {
-    "avl-tree-typed": "^1.19.6",
-    "bst-typed": "^1.19.6",
-    "heap-typed": "^1.19.6",
     "zod": "^3.22.2"
   }
 }