data-structure-typed 1.34.8 → 1.35.0

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,89 +1,7 @@
-import { AbstractBinaryTreeNodeProperties, AbstractBinaryTreeNodeProperty, BinaryTreeDeletedResult, BinaryTreeNodeKey, BinaryTreeNodePropertyName, DFSOrderPattern, FamilyPosition, LoopType, NodeOrPropertyName } from '../types';
+import { BinaryTreeNodeKey } 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);
-    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);
-    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;
-    get loopType(): LoopType;
-    get visitedKey(): BinaryTreeNodeKey[];
-    get visitedVal(): Array<N['val']>;
-    get visitedNode(): N[];
-    get root(): N | null;
-    get size(): number;
-    swapLocation(srcNode: N, destNode: N): N;
-    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;
-    remove(key: BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
-    getDepth(node: N): number;
-    getHeight(beginRoot?: N | null): number;
-    getMinHeight(beginRoot?: N | null): number;
-    isPerfectlyBalanced(beginRoot?: N | null): boolean;
-    getNodes(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
-    has(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName): boolean;
-    get(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName): N | null;
-    getPathToRoot(node: N): N[];
-    getLeftMost(): N | null;
-    getLeftMost(node: N): N;
-    getLeftMost(node?: N | null): N | null;
-    getRightMost(): N | null;
-    getRightMost(node: N): N;
-    getRightMost(node?: N | null): N | null;
-    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;
-    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>;
-    levelIterative(node: N | null): BinaryTreeNodeKey[];
-    levelIterative(node: N | null, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
-    levelIterative(node: N | null, nodeOrPropertyName?: 'val'): N['val'][];
-    levelIterative(node: N | null, nodeOrPropertyName?: 'node'): N[];
-    levelIterative(node: N | null, nodeOrPropertyName?: 'count'): number[];
-    levelIterative(node: N | null, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
-    listLevels(node: N | null): BinaryTreeNodeKey[][];
-    listLevels(node: N | null, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[][];
-    listLevels(node: N | null, nodeOrPropertyName?: 'val'): N['val'][][];
-    listLevels(node: N | null, nodeOrPropertyName?: 'node'): N[][];
-    listLevels(node: N | null, nodeOrPropertyName?: 'count'): number[][];
-    listLevels(node: N | null, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperty<N>[][];
-    getPredecessor(node: N): N;
-    morris(): BinaryTreeNodeKey[];
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
-    morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
-    morris(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
 }

package/lib/interfaces/abstract-graph.d.ts

@@ -1,17 +1,5 @@
 import { VertexKey } from '../types';
 export interface IAbstractGraph<V, E> {
-    hasVertex(vertexOrKey: V | VertexKey): boolean;
-    addVertex(key: VertexKey, val?: V): boolean;
-    removeVertex(vertexOrKey: V | VertexKey): boolean;
-    removeAllVertices(vertices: V[] | VertexKey[]): boolean;
-    degreeOf(vertexOrKey: V | VertexKey): number;
-    edgesOf(vertexOrKey: V | VertexKey): E[];
-    hasEdge(src: V | VertexKey, dest: V | VertexKey): boolean;
-    getEdge(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null;
-    edgeSet(): E[];
-    addEdge(src: V | VertexKey, dest: V | VertexKey, weight: number, val: E): boolean;
-    removeEdge(edge: E): E | null;
-    setEdgeWeight(srcOrKey: V | VertexKey, destOrKey: V | VertexKey, weight: number): boolean;
-    getMinPathBetween(v1: V | VertexKey, v2: V | VertexKey, isWeight?: boolean): V[] | null;
-    getNeighbors(vertexOrKey: V | VertexKey): V[];
+    createVertex(key: VertexKey, val?: V): V;
+    createEdge(srcOrV1: VertexKey | string, destOrV2: VertexKey | string, weight?: number, val?: E): E;
 }

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

@@ -1,8 +1,7 @@
 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/binary-tree.d.ts

@@ -1,4 +1,6 @@
 import { BinaryTreeNode } from '../data-structures';
 import { IAbstractBinaryTree, IAbstractBinaryTreeNode } from './abstract-binary-tree';
-export type IBinaryTreeNode<T, NEIGHBOR extends IBinaryTreeNode<T, NEIGHBOR>> = IAbstractBinaryTreeNode<T, NEIGHBOR>;
-export type IBinaryTree<N extends BinaryTreeNode<N['val'], N>> = IAbstractBinaryTree<N>;
+export interface IBinaryTreeNode<T, NEIGHBOR extends IBinaryTreeNode<T, NEIGHBOR>> extends IAbstractBinaryTreeNode<T, NEIGHBOR> {
+}
+export interface IBinaryTree<N extends BinaryTreeNode<N['val'], N>> extends IAbstractBinaryTree<N> {
+}

package/lib/interfaces/bst.d.ts

@@ -1,16 +1,6 @@
 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;
-    get(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName): N | null;
-    lastKey(): BinaryTreeNodeKey;
-    remove(key: BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
-    getNodes(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName, onlyOne?: boolean): N[];
-    lesserSum(key: BinaryTreeNodeKey, propertyName?: BinaryTreeNodePropertyName): number;
-    allGreaterNodesAdd(node: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
-    perfectlyBalance(): boolean;
-    isAVLBalanced(): boolean;
 }

package/lib/interfaces/directed-graph.d.ts

@@ -1,12 +1,3 @@
-import { VertexKey } from '../types';
 import { IAbstractGraph } from './abstract-graph';
 export interface IDirectedGraph<V, E> extends IAbstractGraph<V, E> {
-    incomingEdgesOf(vertex: V): E[];
-    outgoingEdgesOf(vertex: V): E[];
-    inDegreeOf(vertexOrKey: V | VertexKey): number;
-    outDegreeOf(vertexOrKey: V | VertexKey): number;
-    getEdgeSrc(e: E): V | null;
-    getEdgeDest(e: E): V | null;
-    removeEdgeSrcToDest(srcOrKey: V | VertexKey, destOrKey: V | VertexKey): E | null;
-    removeEdgesBetween(v1: V | VertexKey, v2: V | VertexKey): E[];
 }

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

@@ -1,7 +1,6 @@
 import { RBTreeNode } from '../data-structures';
 import { IBST, IBSTNode } from './bst';
-import { BinaryTreeNodeKey } from '../types';
-export type IRBTreeNode<T, NEIGHBOR extends IRBTreeNode<T, NEIGHBOR>> = IBSTNode<T, NEIGHBOR>;
+export interface IRBTreeNode<T, NEIGHBOR extends IRBTreeNode<T, NEIGHBOR>> extends IBSTNode<T, NEIGHBOR> {
+}
 export interface IRBTree<N extends RBTreeNode<N['val'], N>> extends IBST<N> {
-    createNode(key: BinaryTreeNodeKey, val?: N['val'], count?: number): N;
 }

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

@@ -1,5 +1,6 @@
 import { TreeMultisetNode } from '../data-structures';
-import { IBSTNode } from './bst';
-import { IAVLTree } from './avl-tree';
-export type ITreeMultisetNode<T, NEIGHBOR extends ITreeMultisetNode<T, NEIGHBOR>> = IBSTNode<T, NEIGHBOR>;
-export type ITreeMultiset<N extends TreeMultisetNode<N['val'], N>> = IAVLTree<N>;
+import { IAVLTree, IAVLTreeNode } from './avl-tree';
+export interface ITreeMultisetNode<T, NEIGHBOR extends ITreeMultisetNode<T, NEIGHBOR>> extends IAVLTreeNode<T, NEIGHBOR> {
+}
+export interface ITreeMultiset<N extends TreeMultisetNode<N['val'], N>> extends IAVLTree<N> {
+}

package/lib/interfaces/undirected-graph.d.ts

@@ -1,5 +1,3 @@
-import { VertexKey } from '../types';
 import { IAbstractGraph } from './abstract-graph';
 export interface IUNDirectedGraph<V, E> extends IAbstractGraph<V, E> {
-    removeEdgeBetween(v1: V | VertexKey, v2: V | VertexKey): E | null;
 }

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";