data-structure-typed 1.34.8 → 1.34.9

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

@@ -118,22 +118,22 @@ export class BST extends BinaryTree {
     /**
      * The `addMany` function overrides the base class method to add multiple nodes to a binary search tree in a balanced
      * manner.
-     * @param {[BinaryTreeNodeKey | N , N['val']][]} idsOrNodes - The `idsOrNodes` parameter in the `addMany` function is an array of
+     * @param {[BinaryTreeNodeKey | N , N['val']][]} keysOrNodes - The `keysOrNodes` parameter in the `addMany` function is an array of
      * `BinaryTreeNodeKey` or `N` (node) objects, or `null` values. It represents the nodes or node IDs that need to be added
      * to the binary search tree.
      * @param {N['val'][]} data - The values of tree nodes
      * @param {boolean} isBalanceAdd - If true the nodes will be balance inserted in binary search method.
      * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
      */
-    addMany(idsOrNodes, data, isBalanceAdd = false) {
+    addMany(keysOrNodes, data, isBalanceAdd = false) {
         function hasNoNull(arr) {
             return arr.indexOf(null) === -1;
         }
-        if (!isBalanceAdd || !hasNoNull(idsOrNodes)) {
-            return super.addMany(idsOrNodes, data);
+        if (!isBalanceAdd || !hasNoNull(keysOrNodes)) {
+            return super.addMany(keysOrNodes, data);
         }
         const inserted = [];
-        const combinedArr = idsOrNodes.map((value, index) => [value, data === null || data === void 0 ? void 0 : data[index]]);
+        const combinedArr = keysOrNodes.map((value, index) => [value, data === null || data === void 0 ? void 0 : data[index]]);
         let sorted = [];
         function isNodeOrNullTuple(arr) {
             for (const [keyOrNode] of arr)
@@ -155,7 +155,7 @@ export class BST extends BinaryTree {
             sorted = combinedArr.sort((a, b) => a[0] - b[0]);
         }
         else {
-            throw new Error('Invalid input idsOrNodes');
+            throw new Error('Invalid input keysOrNodes');
         }
         sortedKeysOrNodes = sorted.map(([keyOrNode]) => keyOrNode);
         sortedData = sorted.map(([, val]) => val);
@@ -201,9 +201,8 @@ export class BST extends BinaryTree {
      * specifies the property name to use for searching the binary tree nodes. If not provided, it defaults to `'key'`.
      * @returns The method is returning either a BinaryTreeNodeKey or N (generic type) or null.
      */
-    get(nodeProperty, propertyName) {
+    get(nodeProperty, propertyName = 'key') {
         var _a;
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'key';
         return (_a = this.getNodes(nodeProperty, propertyName, true)[0]) !== null && _a !== void 0 ? _a : null;
     }
     /**
@@ -233,7 +232,7 @@ export class BST extends BinaryTree {
      * is set to `true`, the function will return an array with only one node (if
      * @returns an array of nodes (type N).
      */
-    getNodes(nodeProperty, propertyName = 'key', onlyOne) {
+    getNodes(nodeProperty, propertyName = 'key', onlyOne = false) {
         if (!this.root)
             return [];
         const result = [];
@@ -288,8 +287,7 @@ export class BST extends BinaryTree {
      * @returns The function `lesserSum` returns a number, which represents the sum of the values of the nodes in the
      * binary tree that have a lesser value than the specified `beginNode` based on the `propertyName`.
      */
-    lesserSum(beginNode, propertyName) {
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'key';
+    lesserSum(beginNode, propertyName = 'key') {
         if (typeof beginNode === 'number')
             beginNode = this.get(beginNode, 'key');
         if (!beginNode)
@@ -380,8 +378,7 @@ export class BST extends BinaryTree {
      * 'key'.
      * @returns a boolean value.
      */
-    allGreaterNodesAdd(node, delta, propertyName) {
-        propertyName = propertyName !== null && propertyName !== void 0 ? propertyName : 'key';
+    allGreaterNodesAdd(node, delta, propertyName = 'key') {
         if (typeof node === 'number')
             node = this.get(node, 'key');
         if (!node)
@@ -446,7 +443,7 @@ export class BST extends BinaryTree {
      * @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;
         this.clear();
         if (sorted.length < 1)
             return false;
@@ -534,7 +531,7 @@ export class BST extends BinaryTree {
     /**
      * The function compares two binary tree node IDs using a comparator function and returns whether the first ID is
      * greater than, less than, or equal to the second ID.
-     * @param {BinaryTreeNodeKey} a - a is a BinaryTreeNodeKey, which represents the identifier of a binary tree node.
+     * @param {BinaryTreeNodeKey} a - "a" is a BinaryTreeNodeKey, which represents the identifier of a binary tree node.
      * @param {BinaryTreeNodeKey} b - The parameter "b" in the above code refers to a BinaryTreeNodeKey.
      * @returns a value of type CP (ComparisonResult). The possible return values are CP.gt (greater than), CP.lt (less
      * than), or CP.eq (equal).

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

@@ -11,19 +11,17 @@ 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 key, value, and count.
+     * 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(key: BinaryTreeNodeKey, val?: V, count?: number);
-    private _count;
-    get count(): number;
-    set count(v: 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.
@@ -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 {(BinaryTreeNodeKey | null)[] | (N | null)[]} idsOrNodes - An array of BinaryTreeNodeKey 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 `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: (BinaryTreeNodeKey | 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.
@@ -146,7 +144,7 @@ export declare class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = Tree
     /**
      * 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,24 +163,24 @@ 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.

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 key, value, and count.
+     * 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(key, val, count = 1) {
         super(key, val);
-        this._count = count;
-    }
-    get count() {
-        return this._count;
-    }
-    set count(v) {
-        this._count = v;
+        this.count = count;
     }
 }
 /**
@@ -33,7 +27,7 @@ export class TreeMultiset extends AVLTree {
      * TreeMultiset.
      */
     constructor(options) {
-        super(Object.assign({}, options));
+        super(options);
         this._count = 0;
     }
     get count() {
@@ -84,8 +78,7 @@ export class TreeMultiset extends AVLTree {
      * 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(keyOrNode, val, count) {
-        count = count !== null && count !== void 0 ? count : 1;
+    add(keyOrNode, val, count = 1) {
         let inserted = undefined, newNode;
         if (keyOrNode instanceof TreeMultisetNode) {
             newNode = this.createNode(keyOrNode.key, keyOrNode.val, keyOrNode.count);
@@ -199,17 +192,17 @@ 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 {(BinaryTreeNodeKey | null)[] | (N | null)[]} idsOrNodes - An array of BinaryTreeNodeKey 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 `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 keyOrNode = idsOrNodes[i];
+        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;
@@ -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();
@@ -272,7 +265,7 @@ export class TreeMultiset extends AVLTree {
      * 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(nodeOrKey, ignoreCount) {
+    remove(nodeOrKey, ignoreCount = false) {
         const bstDeletedResult = [];
         if (!this.root)
             return bstDeletedResult;
@@ -442,7 +435,7 @@ export class TreeMultiset extends AVLTree {
      * 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,34 +498,31 @@ 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);
     }
     /**

package/lib/data-structures/graph/abstract-graph.d.ts

@@ -288,7 +288,7 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any> = Abst
         predecessor: (V | null)[][];
     };
     /**
-     * Tarjan is an algorithm based on DFS,which is used to solve the connectivity problem of graphs.
+     * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
      * Tarjan can find cycles in directed or undirected graph
      * Tarjan can find the articulation points and bridges(critical edges) of undirected graphs in linear time,
      * Tarjan solve the bi-connected components of undirected graphs;
@@ -296,7 +296,7 @@ export declare abstract class AbstractGraph<V extends AbstractVertex<any> = Abst
      * /
   
      /**
-     * Tarjan is an algorithm based on DFS,which is used to solve the connectivity problem of graphs.
+     * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
      * Tarjan can find cycles in directed or undirected graph
      * Tarjan can find the articulation points and bridges(critical edges) of undirected graphs in linear time,
      * Tarjan solve the bi-connected components of undirected graphs;

package/lib/data-structures/graph/abstract-graph.js

@@ -775,7 +775,7 @@ export class AbstractGraph {
         return { costs, predecessor };
     }
     /**
-     * Tarjan is an algorithm based on DFS,which is used to solve the connectivity problem of graphs.
+     * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
      * Tarjan can find cycles in directed or undirected graph
      * Tarjan can find the articulation points and bridges(critical edges) of undirected graphs in linear time,
      * Tarjan solve the bi-connected components of undirected graphs;
@@ -783,7 +783,7 @@ export class AbstractGraph {
      * /
   
      /**
-     * Tarjan is an algorithm based on DFS,which is used to solve the connectivity problem of graphs.
+     * Tarjan is an algorithm based on dfs,which is used to solve the connectivity problem of graphs.
      * Tarjan can find cycles in directed or undirected graph
      * Tarjan can find the articulation points and bridges(critical edges) of undirected graphs in linear time,
      * Tarjan solve the bi-connected components of undirected graphs;
@@ -804,8 +804,8 @@ export class AbstractGraph {
      * @returns The function `tarjan` returns an object with the following properties:
      */
     tarjan(needArticulationPoints, needBridges, needSCCs, needCycles) {
-        // !! in undirected graph we will not let child visit parent when DFS
-        // !! articulation point(in DFS search tree not in graph): (cur !== root && cur.has(child)) && (low(child) >= dfn(cur)) || (cur === root && cur.children() >= 2)
+        // !! in undirected graph we will not let child visit parent when dfs
+        // !! articulation point(in dfs search tree not in graph): (cur !== root && cur.has(child)) && (low(child) >= dfn(cur)) || (cur === root && cur.children() >= 2)
         // !! bridge: low(child) > dfn(cur)
         const defaultConfig = false;
         if (needArticulationPoints === undefined)
@@ -832,7 +832,7 @@ export class AbstractGraph {
             dfnMap.set(cur, dfn);
             lowMap.set(cur, dfn);
             const neighbors = this.getNeighbors(cur);
-            let childCount = 0; // child in DFS tree not child in graph
+            let childCount = 0; // child in dfs tree not child in graph
             for (const neighbor of neighbors) {
                 if (neighbor !== parent) {
                     if (dfnMap.get(neighbor) === -1) {

package/lib/data-structures/priority-queue/priority-queue.d.ts

@@ -104,13 +104,13 @@ export declare class PriorityQueue<E = any> {
      */
     sort(): E[];
     /**
-     * The DFS function performs a depth-first search traversal on a binary tree and returns an array of visited nodes
+     * The dfs function performs a depth-first search traversal on a binary tree and returns an array of visited nodes
      * based on the specified traversal order.
      * @param {PriorityQueueDFSOrderPattern} dfsMode - The dfsMode parameter is a string that specifies the order in which
-     * the nodes should be visited during the Depth-First Search (DFS) traversal. It can have one of the following values:
+     * the nodes should be visited during the Depth-First Search (dfs) traversal. It can have one of the following values:
      * @returns an array of type `(E | null)[]`.
      */
-    DFS(dfsMode: PriorityQueueDFSOrderPattern): (E | null)[];
+    dfs(dfsMode: PriorityQueueDFSOrderPattern): (E | null)[];
     protected _setNodes(value: E[]): void;
     protected readonly _comparator: PriorityQueueComparator<E>;
     /**

package/lib/data-structures/priority-queue/priority-queue.js

@@ -174,13 +174,13 @@ export class PriorityQueue {
         return visitedNode;
     }
     /**
-     * The DFS function performs a depth-first search traversal on a binary tree and returns an array of visited nodes
+     * The dfs function performs a depth-first search traversal on a binary tree and returns an array of visited nodes
      * based on the specified traversal order.
      * @param {PriorityQueueDFSOrderPattern} dfsMode - The dfsMode parameter is a string that specifies the order in which
-     * the nodes should be visited during the Depth-First Search (DFS) traversal. It can have one of the following values:
+     * the nodes should be visited during the Depth-First Search (dfs) traversal. It can have one of the following values:
      * @returns an array of type `(E | null)[]`.
      */
-    DFS(dfsMode) {
+    dfs(dfsMode) {
         const visitedNode = [];
         const traverse = (cur) => {
             var _a, _b, _c;

package/lib/interfaces/abstract-binary-tree.d.ts

@@ -1,19 +1,14 @@
 import { AbstractBinaryTreeNodeProperties, AbstractBinaryTreeNodeProperty, BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodePropertyName, DFSOrderPattern, FamilyPosition, LoopType, NodeOrPropertyName } from '../types';
 import { AbstractBinaryTreeNode } from '../data-structures';
 export interface IAbstractBinaryTreeNode<T, NEIGHBOR extends IAbstractBinaryTreeNode<T, NEIGHBOR>> {
-    get key(): BinaryTreeNodeKey;
-    set key(v: BinaryTreeNodeKey);
-    get val(): T | undefined;
-    set val(v: T | undefined);
+    key: BinaryTreeNodeKey;
+    val: T | undefined;
     get left(): NEIGHBOR | null | undefined;
     set left(v: NEIGHBOR | null | undefined);
     get right(): NEIGHBOR | null | undefined;
     set right(v: NEIGHBOR | null | undefined);
-    get parent(): NEIGHBOR | null | undefined;
-    set parent(v: NEIGHBOR | null | undefined);
+    parent: NEIGHBOR | null | undefined;
     get familyPosition(): FamilyPosition;
-    get height(): number;
-    set height(v: number);
 }
 export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'], N>> {
     createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N | null;
@@ -27,8 +22,8 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
     clear(): void;
     isEmpty(): boolean;
     add(key: BinaryTreeNodeKey | N, val?: N['val']): N | null | undefined;
-    addMany(idsOrNodes: (BinaryTreeNodeKey | N | null)[], data?: N['val'][]): (N | null | undefined)[];
-    fill(idsOrNodes: (BinaryTreeNodeKey | N | null)[], data?: N[] | Array<N['val']>): boolean;
+    addMany(keysOrNodes: (BinaryTreeNodeKey | N | null)[], data?: N['val'][]): (N | null | undefined)[];
+    refill(keysOrNodes: (BinaryTreeNodeKey | N | null)[], data?: N[] | Array<N['val']>): boolean;
     remove(key: BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
     getDepth(node: N): number;
     getHeight(beginRoot?: N | null): number;
@@ -49,24 +44,24 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
     getSubTreeSize(subTreeRoot: N | null | undefined): number;
     subTreeSum(subTreeRoot: N, propertyName?: BinaryTreeNodePropertyName): number;
     subTreeAdd(subTreeRoot: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
-    BFS(): BinaryTreeNodeKey[];
-    BFS(nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
-    BFS(nodeOrPropertyName: 'val'): N['val'][];
-    BFS(nodeOrPropertyName: 'node'): N[];
-    BFS(nodeOrPropertyName: 'count'): number[];
-    BFS(nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
-    DFS(): BinaryTreeNodeKey[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
-    DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
-    DFS(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
-    DFSIterative(): BinaryTreeNodeKey[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
-    DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
-    DFSIterative(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    bfs(): BinaryTreeNodeKey[];
+    bfs(nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
+    bfs(nodeOrPropertyName: 'val'): N['val'][];
+    bfs(nodeOrPropertyName: 'node'): N[];
+    bfs(nodeOrPropertyName: 'count'): number[];
+    bfs(nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    dfs(): BinaryTreeNodeKey[];
+    dfs(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
+    dfs(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+    dfs(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+    dfs(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+    dfs(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+    dfsIterative(): BinaryTreeNodeKey[];
+    dfsIterative(pattern: DFSOrderPattern): BinaryTreeNodeKey[];
+    dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
+    dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'val'): N['val'][];
+    dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'node'): N[];
+    dfsIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
     levelIterative(node: N | null): BinaryTreeNodeKey[];
     levelIterative(node: N | null, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
     levelIterative(node: N | null, nodeOrPropertyName?: 'val'): N['val'][];

package/lib/interfaces/avl-tree.d.ts

@@ -1,7 +1,9 @@
 import { AVLTreeNode } from '../data-structures';
 import { IBST, IBSTNode } from './bst';
 import { BinaryTreeDeletedResult, BinaryTreeNodeKey } from '../types';
-export type IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> = IBSTNode<T, NEIGHBOR>;
+export interface IAVLTreeNode<T, NEIGHBOR extends IAVLTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+    height: number;
+}
 export interface IAVLTree<N extends AVLTreeNode<N['val'], N>> extends IBST<N> {
     add(key: BinaryTreeNodeKey, val?: N['val'] | null): N | null | undefined;
     remove(key: BinaryTreeNodeKey): BinaryTreeDeletedResult<N>[];

package/lib/interfaces/bst.d.ts

@@ -1,7 +1,8 @@
 import { BSTNode } from '../data-structures';
 import { IBinaryTree, IBinaryTreeNode } from './binary-tree';
 import { BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodePropertyName } from '../types';
-export type IBSTNode<T, NEIGHBOR extends IBSTNode<T, NEIGHBOR>> = IBinaryTreeNode<T, NEIGHBOR>;
+export interface IBSTNode<T, NEIGHBOR extends IBSTNode<T, NEIGHBOR>> extends IBinaryTreeNode<T, NEIGHBOR> {
+}
 export interface IBST<N extends BSTNode<N['val'], N>> extends IBinaryTree<N> {
     createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N;
     add(key: BinaryTreeNodeKey, val?: N['val'] | null, count?: number): N | null | undefined;

package/lib/types/data-structures/abstract-binary-tree.js

@@ -9,7 +9,6 @@ export var LoopType;
     LoopType["ITERATIVE"] = "ITERATIVE";
     LoopType["RECURSIVE"] = "RECURSIVE";
 })(LoopType || (LoopType = {}));
-/* This enumeration defines the position of a node within a family tree composed of three associated nodes, where 'root' represents the root node of the family tree, 'left' represents the left child node, and 'right' represents the right child node. */
 export var FamilyPosition;
 (function (FamilyPosition) {
     FamilyPosition["ROOT"] = "ROOT";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.34.8",
+  "version": "1.34.9",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/index.js",
   "module": "lib/index.js",
@@ -23,7 +23,7 @@
     "fix:test": "npm run lint:test && npm run format:test",
     "fix": "npm run fix:src && npm run fix:test",
     "update:test-deps": "npm i avl-tree-typed binary-tree-typed bst-typed heap-typed --save-dev",
-    "update-all: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 queue-typed --save-dev",
+    "install:individuals": "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 queue-typed --save-dev",
     "test": "jest",
     "check:deps": "dependency-cruiser src",
     "changelog": "auto-changelog",
@@ -50,17 +50,17 @@
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "auto-changelog": "^2.4.0",
-    "avl-tree-typed": "^1.34.1",
+    "avl-tree-typed": "^1.34.8",
     "benchmark": "^2.1.4",
-    "binary-tree-typed": "^1.34.1",
-    "bst-typed": "^1.34.1",
+    "binary-tree-typed": "^1.34.8",
+    "bst-typed": "^1.34.8",
     "dependency-cruiser": "^14.1.0",
     "eslint": "^8.50.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-import-resolver-alias": "^1.1.2",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-import": "^2.28.1",
-    "heap-typed": "^1.34.1",
+    "heap-typed": "^1.34.8",
     "istanbul-badges-readme": "^1.8.5",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",