data-structure-typed 1.34.8 → 1.34.9

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

@@ -13,8 +13,11 @@ export class AVLTreeNode<V = any, NEIGHBOR extends AVLTreeNode<V, NEIGHBOR> = AV
   extends BSTNode<V, NEIGHBOR>
   implements IAVLTreeNode<V, NEIGHBOR>
 {
+  height: number;
+
   constructor(key: BinaryTreeNodeKey, val?: V) {
     super(key, val);
+    this.height = 0;
   }
 }
 
@@ -29,6 +32,32 @@ export class AVLTree<N extends AVLTreeNode<N['val'], N> = AVLTreeNode> extends B
     super(options);
   }
 
+  /**
+   * The `swapLocation` function swaps the location of two nodes in a binary tree.
+   * @param {N} srcNode - The source node that you want to swap with the destination node.
+   * @param {N} destNode - The `destNode` parameter represents the destination node where the values from `srcNode` will
+   * be swapped to.
+   * @returns The `destNode` is being returned.
+   */
+  override swapLocation(srcNode: N, destNode: N): N {
+    const {key, val, height} = destNode;
+    const tempNode = this.createNode(key, val);
+
+    if (tempNode) {
+      tempNode.height = height;
+
+      destNode.key = srcNode.key;
+      destNode.val = srcNode.val;
+      destNode.height = srcNode.height;
+
+      srcNode.key = tempNode.key;
+      srcNode.val = tempNode.val;
+      srcNode.height = tempNode.height;
+    }
+
+    return destNode;
+  }
+
   /**
    * The function creates a new AVL tree node with the given key and value.
    * @param {BinaryTreeNodeKey} key - The `key` parameter is the identifier for the binary tree node. It is used to uniquely

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

@@ -130,7 +130,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
   /**
    * 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
@@ -138,18 +138,18 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
    * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
    */
   override addMany(
-    idsOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[],
+    keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[],
     data?: N['val'][],
     isBalanceAdd = false
   ): (N | null | undefined)[] {
     function hasNoNull(arr: (BinaryTreeNodeKey | null)[] | (N | null)[]): arr is BinaryTreeNodeKey[] | N[] {
       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: (N | null | undefined)[] = [];
-    const combinedArr: [BinaryTreeNodeKey | N, N['val']][] = idsOrNodes.map((value, index) => [value, data?.[index]]);
+    const combinedArr: [BinaryTreeNodeKey | N, N['val']][] = keysOrNodes.map((value, index) => [value, data?.[index]]);
     let sorted = [];
     function isNodeOrNullTuple(arr: [BinaryTreeNodeKey | N, N['val']][]): arr is [N, N['val']][] {
       for (const [keyOrNode] of arr) if (keyOrNode instanceof BSTNode) return true;
@@ -169,7 +169,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
     } else if (isBinaryTreeKeyOrNullTuple(combinedArr)) {
       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);
@@ -216,8 +216,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
    * 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.
    */
-  override get(nodeProperty: BinaryTreeNodeKey | N, propertyName?: BinaryTreeNodePropertyName): N | null {
-    propertyName = propertyName ?? 'key';
+  override get(nodeProperty: BinaryTreeNodeKey | N, propertyName: BinaryTreeNodePropertyName = 'key'): N | null {
     return this.getNodes(nodeProperty, propertyName, true)[0] ?? null;
   }
 
@@ -248,7 +247,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
   override getNodes(
     nodeProperty: BinaryTreeNodeKey | N,
     propertyName: BinaryTreeNodePropertyName = 'key',
-    onlyOne?: boolean
+    onlyOne = false
   ): N[] {
     if (!this.root) return [];
     const result: N[] = [];
@@ -298,8 +297,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
    * @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: N | BinaryTreeNodeKey | null, propertyName?: BinaryTreeNodePropertyName): number {
-    propertyName = propertyName ?? 'key';
+  lesserSum(beginNode: N | BinaryTreeNodeKey | null, propertyName: BinaryTreeNodePropertyName = 'key'): number {
     if (typeof beginNode === 'number') beginNode = this.get(beginNode, 'key');
     if (!beginNode) return 0;
     if (!this.root) return 0;
@@ -378,9 +376,8 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
   allGreaterNodesAdd(
     node: N | BinaryTreeNodeKey | null,
     delta: number,
-    propertyName?: BinaryTreeNodePropertyName
+    propertyName: BinaryTreeNodePropertyName = 'key'
   ): boolean {
-    propertyName = propertyName ?? 'key';
     if (typeof node === 'number') node = this.get(node, 'key');
     if (!node) return false;
     const key = node.key;
@@ -440,7 +437,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
    * @returns The function `perfectlyBalance()` returns a boolean value.
    */
   perfectlyBalance(): boolean {
-    const sorted = this.DFS('in', 'node'),
+    const sorted = this.dfs('in', 'node'),
       n = sorted.length;
     this.clear();
 
@@ -529,7 +526,7 @@ export class BST<N extends BSTNode<N['val'], N> = BSTNode> extends BinaryTree<N>
   /**
    * 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/src/data-structures/binary-tree/tree-multiset.ts

@@ -15,29 +15,21 @@ export class TreeMultisetNode<V = any, NEIGHBOR extends TreeMultisetNode<V, NEIG
   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 = 1) {
     super(key, val);
-    this._count = count;
+    this.count = count;
   }
 
-  private _count: number;
-
-  get count(): number {
-    return this._count;
-  }
-
-  set count(v: number) {
-    this._count = v;
-  }
+  count: number;
 }
 
 /**
@@ -54,7 +46,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
    * TreeMultiset.
    */
   constructor(options?: TreeMultisetOptions) {
-    super({...options});
+    super(options);
   }
 
   private _count = 0;
@@ -113,8 +105,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
    * value should be added to the binary tree. If the `count` parameter is not provided, it defaults to 1.
    * @returns The method `add` returns either the inserted node (`N`), `null`, or `undefined`.
    */
-  override add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val'], count?: number): N | null | undefined {
-    count = count ?? 1;
+  override add(keyOrNode: BinaryTreeNodeKey | N | null, val?: N['val'], count = 1): N | null | undefined {
     let inserted: N | null | undefined = undefined,
       newNode: N | null;
     if (keyOrNode instanceof TreeMultisetNode) {
@@ -219,7 +210,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
   /**
    * 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()`
@@ -227,13 +218,13 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
    * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
    */
   override addMany(
-    idsOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[],
+    keysOrNodes: (BinaryTreeNodeKey | null)[] | (N | null)[],
     data?: N['val'][]
   ): (N | null | undefined)[] {
     const inserted: (N | null | undefined)[] = [];
 
-    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));
@@ -256,7 +247,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
    * @returns The function `perfectlyBalance()` returns a boolean value.
    */
   override perfectlyBalance(): boolean {
-    const sorted = this.DFS('in', 'node'),
+    const sorted = this.dfs('in', 'node'),
       n = sorted.length;
     if (sorted.length < 1) return false;
 
@@ -302,7 +293,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
    * 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.
    */
-  override remove(nodeOrKey: N | BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[] {
+  override remove(nodeOrKey: N | BinaryTreeNodeKey, ignoreCount = false): BinaryTreeDeletedResult<N>[] {
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];
     if (!this.root) return bstDeletedResult;
 
@@ -483,7 +474,7 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
    * to `true`, the function will return only one node. If `onlyOne`
    * @returns an array of nodes that match the given nodeProperty.
    */
-  getNodesByCount(nodeProperty: BinaryTreeNodeKey | N, onlyOne?: boolean): N[] {
+  getNodesByCount(nodeProperty: BinaryTreeNodeKey | N, onlyOne = false): N[] {
     if (!this.root) return [];
     const result: N[] = [];
 
@@ -522,10 +513,10 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
   /**
    * 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[] {
-    const nodes = super.BFS('node');
+    const nodes = super.bfs('node');
     return nodes.map(node => node.count);
   }
 
@@ -549,36 +540,33 @@ export class TreeMultiset<N extends TreeMultisetNode<N['val'], N> = TreeMultiset
    * 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[] {
-    pattern = pattern || 'in';
+  morrisCount(pattern: DFSOrderPattern = 'in'): number[] {
     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?: 'in' | 'pre' | 'post'): number[] {
-    pattern = pattern ?? 'in';
-    const nodes = super.DFSIterative(pattern, 'node');
+  dfsCountIterative(pattern: DFSOrderPattern = 'in'): number[] {
+    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?: DFSOrderPattern): number[] {
-    pattern = pattern ?? 'in';
-    const nodes = super.DFS(pattern, 'node');
+  dfsCount(pattern: DFSOrderPattern = 'in'): number[] {
+    const nodes = super.dfs(pattern, 'node');
     return nodes.map(node => node.count);
   }
 

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

@@ -889,7 +889,7 @@ export abstract 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;
@@ -897,7 +897,7 @@ export abstract 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;
@@ -918,8 +918,8 @@ export abstract class AbstractGraph<
    * @returns The function `tarjan` returns an object with the following properties:
    */
   tarjan(needArticulationPoints?: boolean, needBridges?: boolean, needSCCs?: boolean, needCycles?: boolean) {
-    // !! 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;
@@ -947,7 +947,7 @@ export abstract class AbstractGraph<
       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/src/data-structures/priority-queue/priority-queue.ts

@@ -195,13 +195,13 @@ export class PriorityQueue<E = any> {
   }
 
   /**
-   * 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)[] {
     const visitedNode: (E | null)[] = [];
 
     const traverse = (cur: number) => {

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

@@ -12,13 +12,9 @@ import {
 import {AbstractBinaryTreeNode} from '../data-structures';
 
 export interface IAbstractBinaryTreeNode<T, NEIGHBOR extends IAbstractBinaryTreeNode<T, NEIGHBOR>> {
-  get key(): BinaryTreeNodeKey;
+  key: BinaryTreeNodeKey;
 
-  set key(v: BinaryTreeNodeKey);
-
-  get val(): T | undefined;
-
-  set val(v: T | undefined);
+  val: T | undefined;
 
   get left(): NEIGHBOR | null | undefined;
 
@@ -28,15 +24,9 @@ export interface IAbstractBinaryTreeNode<T, NEIGHBOR extends IAbstractBinaryTree
 
   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>> {
@@ -62,9 +52,9 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
 
   add(key: BinaryTreeNodeKey | N, val?: N['val']): N | null | undefined;
 
-  addMany(idsOrNodes: (BinaryTreeNodeKey | N | null)[], data?: N['val'][]): (N | null | undefined)[];
+  addMany(keysOrNodes: (BinaryTreeNodeKey | N | null)[], data?: N['val'][]): (N | null | undefined)[];
 
-  fill(idsOrNodes: (BinaryTreeNodeKey | N | null)[], data?: N[] | Array<N['val']>): boolean;
+  refill(keysOrNodes: (BinaryTreeNodeKey | N | null)[], data?: N[] | Array<N['val']>): boolean;
 
   remove(key: BinaryTreeNodeKey, ignoreCount?: boolean): BinaryTreeDeletedResult<N>[];
 
@@ -108,44 +98,41 @@ export interface IAbstractBinaryTree<N extends AbstractBinaryTreeNode<N['val'],
 
   subTreeAdd(subTreeRoot: N, delta: number, propertyName?: BinaryTreeNodePropertyName): boolean;
 
-  BFS(): BinaryTreeNodeKey[];
+  bfs(): BinaryTreeNodeKey[];
 
-  BFS(nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
+  bfs(nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
 
-  BFS(nodeOrPropertyName: 'val'): N['val'][];
+  bfs(nodeOrPropertyName: 'val'): N['val'][];
 
-  BFS(nodeOrPropertyName: 'node'): N[];
+  bfs(nodeOrPropertyName: 'node'): N[];
 
-  BFS(nodeOrPropertyName: 'count'): number[];
+  bfs(nodeOrPropertyName: 'count'): number[];
 
-  BFS(nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+  bfs(nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
 
-  DFS(): BinaryTreeNodeKey[];
+  dfs(): BinaryTreeNodeKey[];
 
-  DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
+  dfs(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
 
-  DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+  dfs(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
 
-  DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+  dfs(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
 
-  DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+  dfs(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
 
-  DFS(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
+  dfs(pattern?: 'in' | 'pre' | 'post', nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
 
-  DFSIterative(): BinaryTreeNodeKey[];
+  dfsIterative(): BinaryTreeNodeKey[];
 
-  DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'key'): BinaryTreeNodeKey[];
+  dfsIterative(pattern: DFSOrderPattern): BinaryTreeNodeKey[];
 
-  DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): N[];
+  dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'key'): BinaryTreeNodeKey[];
 
-  DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): N[];
+  dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'val'): N['val'][];
 
-  DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+  dfsIterative(pattern: DFSOrderPattern, nodeOrPropertyName: 'node'): N[];
 
-  DFSIterative(
-    pattern?: 'in' | 'pre' | 'post',
-    nodeOrPropertyName?: NodeOrPropertyName
-  ): AbstractBinaryTreeNodeProperties<N>;
+  dfsIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: NodeOrPropertyName): AbstractBinaryTreeNodeProperties<N>;
 
   levelIterative(node: N | null): BinaryTreeNodeKey[];
 

package/src/interfaces/avl-tree.ts

@@ -2,7 +2,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;

package/src/interfaces/bst.ts

@@ -2,7 +2,7 @@ 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;

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

@@ -12,7 +12,6 @@ export enum LoopType {
   RECURSIVE = 'RECURSIVE'
 }
 
-/* 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 enum FamilyPosition {
   ROOT = 'ROOT',
   LEFT = 'LEFT',

package/test/integration/avl-tree.test.ts

@@ -12,15 +12,15 @@ describe('AVL Tree Test', () => {
     expect(node6 && tree.getHeight(node6)).toBe(3);
     expect(node6 && tree.getDepth(node6)).toBe(1);
 
-    const getNodeById = tree.get(10, 'id');
-    expect(getNodeById?.id).toBe(10);
+    const getNodeById = tree.get(10, 'key');
+    expect(getNodeById?.key).toBe(10);
 
     const getMinNodeByRoot = tree.getLeftMost();
-    expect(getMinNodeByRoot?.id).toBe(1);
+    expect(getMinNodeByRoot?.key).toBe(1);
 
     const node15 = tree.get(15);
     const getMinNodeBySpecificNode = node15 && tree.getLeftMost(node15);
-    expect(getMinNodeBySpecificNode?.id).toBe(12);
+    expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     const subTreeSum = node15 && tree.subTreeSum(node15);
     expect(subTreeSum).toBe(70);
@@ -32,65 +32,65 @@ describe('AVL Tree Test', () => {
     expect(node15?.val).toBe(15);
 
     const dfs = tree.DFS('in', 'node');
-    expect(dfs[0].id).toBe(1);
-    expect(dfs[dfs.length - 1].id).toBe(16);
+    expect(dfs[0].key).toBe(1);
+    expect(dfs[dfs.length - 1].key).toBe(16);
 
     tree.perfectlyBalance();
     const bfs = tree.BFS('node');
     expect(tree.isPerfectlyBalanced()).toBe(true);
-    expect(bfs[0].id).toBe(8);
-    expect(bfs[bfs.length - 1].id).toBe(16);
+    expect(bfs[0].key).toBe(8);
+    expect(bfs[bfs.length - 1].key).toBe(16);
 
-    expect(tree.remove(11)[0].deleted?.id).toBe(11);
+    expect(tree.remove(11)[0].deleted?.key).toBe(11);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(node15 && tree.getHeight(node15)).toBe(2);
 
-    expect(tree.remove(1)[0].deleted?.id).toBe(1);
+    expect(tree.remove(1)[0].deleted?.key).toBe(1);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(4);
 
-    expect(tree.remove(4)[0].deleted?.id).toBe(4);
+    expect(tree.remove(4)[0].deleted?.key).toBe(4);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(4);
 
-    expect(tree.remove(10)[0].deleted?.id).toBe(10);
+    expect(tree.remove(10)[0].deleted?.key).toBe(10);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(15)[0].deleted?.id).toBe(15);
+    expect(tree.remove(15)[0].deleted?.key).toBe(15);
     expect(tree.isAVLBalanced()).toBe(true);
 
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(5)[0].deleted?.id).toBe(5);
+    expect(tree.remove(5)[0].deleted?.key).toBe(5);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(13)[0].deleted?.id).toBe(13);
+    expect(tree.remove(13)[0].deleted?.key).toBe(13);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(3)[0].deleted?.id).toBe(3);
+    expect(tree.remove(3)[0].deleted?.key).toBe(3);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(8)[0].deleted?.id).toBe(8);
+    expect(tree.remove(8)[0].deleted?.key).toBe(8);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(3);
 
-    expect(tree.remove(6)[0].deleted?.id).toBe(6);
+    expect(tree.remove(6)[0].deleted?.key).toBe(6);
     expect(tree.remove(6).length).toBe(0);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
 
-    expect(tree.remove(7)[0].deleted?.id).toBe(7);
+    expect(tree.remove(7)[0].deleted?.key).toBe(7);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
 
-    expect(tree.remove(9)[0].deleted?.id).toBe(9);
+    expect(tree.remove(9)[0].deleted?.key).toBe(9);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(2);
-    expect(tree.remove(14)[0].deleted?.id).toBe(14);
+    expect(tree.remove(14)[0].deleted?.key).toBe(14);
     expect(tree.isAVLBalanced()).toBe(true);
     expect(tree.getHeight()).toBe(1);
 
@@ -101,8 +101,8 @@ describe('AVL Tree Test', () => {
     expect(lastBFSIds[2]).toBe(16);
 
     const lastBFSNodes = tree.BFS('node');
-    expect(lastBFSNodes[0].id).toBe(12);
-    expect(lastBFSNodes[1].id).toBe(2);
-    expect(lastBFSNodes[2].id).toBe(16);
+    expect(lastBFSNodes[0].key).toBe(12);
+    expect(lastBFSNodes[1].key).toBe(2);
+    expect(lastBFSNodes[2].key).toBe(16);
   });
 });