data-structure-typed 2.1.2 → 2.2.1

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

@@ -6,7 +6,15 @@
  * @license MIT License
  */
 
-import type { BTNOptKeyOrNull, ElemOf, EntryCallback, RedBlackTreeOptions, TreeMultiMapOptions } from '../../types';
+import type {
+  BTNOptKeyOrNull,
+  ElemOf,
+  EntryCallback,
+  FamilyPosition,
+  RBTNColor,
+  RedBlackTreeOptions,
+  TreeMultiMapOptions
+} from '../../types';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 import { IBinaryTree } from '../../interfaces';
 
@@ -16,8 +24,10 @@ import { IBinaryTree } from '../../interfaces';
  * @template K
  * @template V
  */
-export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]> {
-  override parent?: TreeMultiMapNode<K, V> = undefined;
+export class TreeMultiMapNode<K = any, V = any> {
+  key: K;
+  value?: V[];
+  parent?: TreeMultiMapNode<K, V> = undefined;
 
   /**
    * Create a TreeMultiMap node with an optional value bucket.
@@ -26,18 +36,20 @@ export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]>
    * @param [value] - Initial array of values.
    * @returns New TreeMultiMapNode instance.
    */
-  constructor(key: K, value?: V[]) {
-    super(key, value);
+  constructor(key: K, value: V[] = [], color: RBTNColor = 'BLACK') {
+    this.key = key;
+    this.value = value;
+    this.color = color;
   }
 
-  override _left?: TreeMultiMapNode<K, V> | null | undefined = undefined;
+  _left?: TreeMultiMapNode<K, V> | null | undefined = undefined;
 
   /**
    * Get the left child pointer.
    * @remarks Time O(1), Space O(1)
    * @returns Left child node, or null/undefined.
    */
-  override get left(): TreeMultiMapNode<K, V> | null | undefined {
+  get left(): TreeMultiMapNode<K, V> | null | undefined {
     return this._left;
   }
 
@@ -47,21 +59,21 @@ export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]>
    * @param v - New left child node, or null/undefined.
    * @returns void
    */
-  override set left(v: TreeMultiMapNode<K, V> | null | undefined) {
+  set left(v: TreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._left = v;
   }
 
-  override _right?: TreeMultiMapNode<K, V> | null | undefined = undefined;
+  _right?: TreeMultiMapNode<K, V> | null | undefined = undefined;
 
   /**
    * Get the right child pointer.
    * @remarks Time O(1), Space O(1)
    * @returns Right child node, or null/undefined.
    */
-  override get right(): TreeMultiMapNode<K, V> | null | undefined {
+  get right(): TreeMultiMapNode<K, V> | null | undefined {
     return this._right;
   }
 
@@ -71,12 +83,98 @@ export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]>
    * @param v - New right child node, or null/undefined.
    * @returns void
    */
-  override set right(v: TreeMultiMapNode<K, V> | null | undefined) {
+  set right(v: TreeMultiMapNode<K, V> | null | undefined) {
     if (v) {
       v.parent = this;
     }
     this._right = v;
   }
+
+  _height: number = 0;
+
+  /**
+   * Gets the height of the node (used in self-balancing trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The height.
+   */
+  get height(): number {
+    return this._height;
+  }
+
+  /**
+   * Sets the height of the node.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new height.
+   */
+  set height(value: number) {
+    this._height = value;
+  }
+
+  _color: RBTNColor = 'BLACK';
+
+  /**
+   * Gets the color of the node (used in Red-Black trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The node's color.
+   */
+  get color(): RBTNColor {
+    return this._color;
+  }
+
+  /**
+   * Sets the color of the node.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new color.
+   */
+  set color(value: RBTNColor) {
+    this._color = value;
+  }
+
+  _count: number = 1;
+
+  /**
+   * Gets the count of nodes in the subtree rooted at this node (used in order-statistic trees).
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The subtree node count.
+   */
+  get count(): number {
+    return this._count;
+  }
+
+  /**
+   * Sets the count of nodes in the subtree.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param value - The new count.
+   */
+  set count(value: number) {
+    this._count = value;
+  }
+
+  /**
+   * Gets the position of the node relative to its parent.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @returns The family position (e.g., 'ROOT', 'LEFT', 'RIGHT').
+   */
+  get familyPosition(): FamilyPosition {
+    if (!this.parent) {
+      return this.left || this.right ? 'ROOT' : 'ISOLATED';
+    }
+
+    if (this.parent.left === this) {
+      return this.left || this.right ? 'ROOT_LEFT' : 'LEFT';
+    } else if (this.parent.right === this) {
+      return this.left || this.right ? 'ROOT_RIGHT' : 'RIGHT';
+    }
+
+    return 'MAL_NODE';
+  }
 }
 
 /**
@@ -85,6 +183,7 @@ export class TreeMultiMapNode<K = any, V = any> extends RedBlackTreeNode<K, V[]>
  * @template K
  * @template V
  * @template R
+ *
  * @example
  * // players ranked by score with their equipment
  *     type Equipment = {
@@ -274,6 +373,19 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
     return new TreeMultiMapNode<K, V>(key, this._isMapMode ? [] : value);
   }
 
+  /**
+   * Checks if the given item is a `TreeMultiMapNode` instance.
+   * @remarks Time O(1), Space O(1)
+   *
+   * @param keyNodeOrEntry - The item to check.
+   * @returns True if it's a TreeMultiMapNode, false otherwise.
+   */
+  override isNode(
+    keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
+  ): keyNodeOrEntry is TreeMultiMapNode<K, V> {
+    return keyNodeOrEntry instanceof TreeMultiMapNode;
+  }
+
   override add(
     keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
   ): boolean;
@@ -392,7 +504,7 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
   ): RedBlackTree<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);
     let i = 0;
-    for (const [k, v] of this) out.add(callback.call(thisArg, k, v, i++, this));
+    for (const [k, v] of this) out.add(callback.call(thisArg, v, k, i++, this));
     return out;
   }
 

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

@@ -50,11 +50,11 @@ export abstract class AbstractEdge<E = any> {
  * @example examples will be generated by unit test
  */
 export abstract class AbstractGraph<
-    V = any,
-    E = any,
-    VO extends AbstractVertex<V> = AbstractVertex<V>,
-    EO extends AbstractEdge<E> = AbstractEdge<E>
-  >
+  V = any,
+  E = any,
+  VO extends AbstractVertex<V> = AbstractVertex<V>,
+  EO extends AbstractEdge<E> = AbstractEdge<E>
+>
   extends IterableEntryBase<VertexKey, V | undefined>
   implements IGraph<V, E, VO, EO>
 {
@@ -897,7 +897,7 @@ export abstract class AbstractGraph<
     const filtered: [VertexKey, V | undefined][] = [];
     let index = 0;
     for (const [key, value] of this) {
-      if (predicate.call(thisArg, key, value, index, this)) {
+      if (predicate.call(thisArg, value, key, index, this)) {
         filtered.push([key, value]);
       }
       index++;
@@ -916,7 +916,7 @@ export abstract class AbstractGraph<
     const filtered: [VertexKey, V | undefined][] = [];
     let index = 0;
     for (const [key, value] of this) {
-      if (predicate.call(thisArg, key, value, index, this)) {
+      if (predicate.call(thisArg, value, key, index, this)) {
         filtered.push([key, value]);
       }
       index++;
@@ -928,7 +928,7 @@ export abstract class AbstractGraph<
     const mapped: T[] = [];
     let index = 0;
     for (const [key, value] of this) {
-      mapped.push(callback.call(thisArg, key, value, index, this));
+      mapped.push(callback.call(thisArg, value, key, index, this));
       index++;
     }
     return mapped;

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

@@ -38,11 +38,11 @@ export class DirectedEdge<E = any> extends AbstractEdge<E> {
  * @example examples will be generated by unit test
  */
 export class DirectedGraph<
-    V = any,
-    E = any,
-    VO extends DirectedVertex<V> = DirectedVertex<V>,
-    EO extends DirectedEdge<E> = DirectedEdge<E>
-  >
+  V = any,
+  E = any,
+  VO extends DirectedVertex<V> = DirectedVertex<V>,
+  EO extends DirectedEdge<E> = DirectedEdge<E>
+>
   extends AbstractGraph<V, E, VO, EO>
   implements IGraph<V, E, VO, EO>
 {

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

@@ -36,11 +36,11 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
  * @example examples will be generated by unit test
  */
 export class UndirectedGraph<
-    V = any,
-    E = any,
-    VO extends UndirectedVertex<V> = UndirectedVertex<V>,
-    EO extends UndirectedEdge<E> = UndirectedEdge<E>
-  >
+  V = any,
+  E = any,
+  VO extends UndirectedVertex<V> = UndirectedVertex<V>,
+  EO extends UndirectedEdge<E> = UndirectedEdge<E>
+>
   extends AbstractGraph<V, E, VO, EO>
   implements IGraph<V, E, VO, EO>
 {

package/src/data-structures/hash/hash-map.ts

@@ -290,7 +290,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   map<VM>(callbackfn: EntryCallback<K, V, VM>, thisArg?: any): any {
     const out = this._createLike<K, VM, [K, VM]>();
     let index = 0;
-    for (const [key, value] of this) out.set(key, callbackfn.call(thisArg, key, value, index++, this));
+    for (const [key, value] of this) out.set(key, callbackfn.call(thisArg, value, key, index++, this));
     return out;
   }
 
@@ -305,7 +305,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
   filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): any {
     const out = this._createLike<K, V, [K, V]>();
     let index = 0;
-    for (const [key, value] of this) if (predicate.call(thisArg, key, value, index++, this)) out.set(key, value);
+    for (const [key, value] of this) if (predicate.call(thisArg, value, key, index++, this)) out.set(key, value);
     return out;
   }
 
@@ -677,7 +677,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     const out = this._createLike<K, V, [K, V]>();
     let index = 0;
     for (const [key, value] of this) {
-      if (predicate.call(thisArg, key, value, index, this)) out.set(key, value);
+      if (predicate.call(thisArg, value, key, index, this)) out.set(key, value);
       index++;
     }
     return out;
@@ -696,7 +696,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     const out = this._createLike<MK, MV, [MK, MV]>();
     let index = 0;
     for (const [key, value] of this) {
-      const [newKey, newValue] = callback.call(thisArg, key, value, index, this);
+      const [newKey, newValue] = callback.call(thisArg, value, key, index, this);
       out.set(newKey, newValue);
       index++;
     }

package/src/types/data-structures/base/base.ts

@@ -1,7 +1,7 @@
 import { IterableElementBase, IterableEntryBase } from '../../../data-structures';
 import { LinearBase } from '../../../data-structures/base/linear-base';
 
-export type EntryCallback<K, V, R> = (key: K, value: V, index: number, original: IterableEntryBase<K, V>) => R;
+export type EntryCallback<K, V, R> = (value: V, key: K, index: number, original: IterableEntryBase<K, V>) => R;
 export type ElementCallback<E, R, RT> = (element: E, index: number, original: IterableElementBase<E, R>) => RT;
 export type ReduceEntryCallback<K, V, R> = (
   accumulator: R,

package/test/performance/data-structures/binary-tree/red-black-tree.test.ts

@@ -2,57 +2,60 @@ import { RedBlackTree } from '../../../../src';
 import * as Benchmark from 'benchmark';
 import { getRandomIntArray, magnitude } from '../../../utils';
 import { OrderedMap } from 'js-sdsl';
-import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
 const rbTree = new RedBlackTree<number>();
-const rbTreeNodeMode = new RedBlackTree<number>([], { isMapMode: false });
+// const rbTreeNodeMode = new RedBlackTree<number>([], { isMapMode: false });
 
-const { HUNDRED_THOUSAND } = magnitude;
-const randomArray = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSAND - 1, true);
+const { MILLION } = magnitude;
+const randomArray = getRandomIntArray(MILLION, 0, MILLION - 1, true);
 const cOrderedMap = new OrderedMap<number, number>();
 
 suite
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add randomly`, () => {
-    rbTree.clear();
-    for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
+  // .add(`${MILLION.toLocaleString()} add randomly`, () => {
+  //   rbTree.clear();
+  //   for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
+  // })
+  .add(`${MILLION.toLocaleString()} add`, () => {
     rbTree.clear();
     for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
   })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} get`, () => {
+  .add(`${MILLION.toLocaleString()} get`, () => {
     for (let i = 0; i < randomArray.length; i++) rbTree.get(randomArray[i]);
   })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} getNode`, () => {
-    for (let i = 0; i < randomArray.length; i++) rbTree.getNode(randomArray[i]);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} node mode add randomly`, () => {
-    rbTreeNodeMode.clear();
-    for (let i = 0; i < randomArray.length; i++) rbTreeNodeMode.add(randomArray[i]);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} node mode get`, () => {
-    for (let i = 0; i < randomArray.length; i++) rbTreeNodeMode.get(randomArray[i]);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} iterator`, () => {
+  // .add(`${MILLION.toLocaleString()} getNode`, () => {
+  //   for (let i = 0; i < randomArray.length; i++) rbTree.getNode(randomArray[i]);
+  // })
+  // .add(`${MILLION.toLocaleString()} node mode add randomly`, () => {
+  //   rbTreeNodeMode.clear();
+  //   for (let i = 0; i < randomArray.length; i++) rbTreeNodeMode.add(randomArray[i]);
+  // })
+  // .add(`${MILLION.toLocaleString()} node mode get`, () => {
+  //   for (let i = 0; i < randomArray.length; i++) rbTreeNodeMode.get(randomArray[i]);
+  // })
+  .add(`${MILLION.toLocaleString()} iterator`, () => {
     const entries = [...rbTree];
-    return entries.length === HUNDRED_THOUSAND;
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete orderly`, () => {
-    rbTree.clear();
-    for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
-    for (let i = 0; i < randomArray.length; i++) rbTree.delete(i);
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & delete randomly`, () => {
-    rbTree.clear();
-    for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
-    for (let i = 0; i < randomArray.length; i++) rbTree.delete(randomArray[i]);
+    return entries.length === MILLION;
   });
+// .add(`${MILLION.toLocaleString()} add & delete orderly`, () => {
+//   rbTree.clear();
+//   for (let i = 0; i < randomArray.length; i++) rbTree.add(i);
+//   for (let i = 0; i < randomArray.length; i++) rbTree.delete(i);
+// })
+// .add(`${MILLION.toLocaleString()} add & delete randomly`, () => {
+//   rbTree.clear();
+//   for (let i = 0; i < randomArray.length; i++) rbTree.add(randomArray[i]);
+//   for (let i = 0; i < randomArray.length; i++) rbTree.delete(randomArray[i]);
+// });
 
-if (isCompetitor) {
-  suite.add(`CPT ${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
-    for (let i = 0; i < randomArray.length; i++) cOrderedMap.setElement(randomArray[i], randomArray[i]);
-  });
+if (true) {
+  suite
+    .add(`CPT ${MILLION.toLocaleString()} add`, () => {
+      for (let i = 0; i < randomArray.length; i++) cOrderedMap.setElement(randomArray[i], randomArray[i]);
+    })
+    .add(`CPT ${MILLION.toLocaleString()} add`, () => {
+      for (let i = 0; i < randomArray.length; i++) cOrderedMap.getElementByKey(randomArray[i]);
+    });
 }
 
 export { suite };

package/test/performance/runner-config.json

@@ -17,20 +17,20 @@
     "**/experimental/**"
   ],
   "order": [
+    "red-black-tree",
+    "queue",
+    "deque",
     "heap",
     "avl-tree",
-    "red-black-tree",
     "doubly-linked-list",
+    "singly-linked-list",
     "linked-hash-map",
     "hash-map",
     "map-graph",
     "graph",
     "directed-graph",
     "undirected-graph",
-    "queue",
-    "deque",
     "priority-queue",
-    "singly-linked-list",
     "binary-tree-overall",
     "bst",
     "trie",

package/test/unit/data-structures/binary-tree/avl-tree-counter.test.ts

@@ -1,4 +1,4 @@
-import { AVLTreeCounter, AVLTreeCounterNode, AVLTreeNode, BinaryTreeNode, BSTNode, IBinaryTree } from '../../../../src';
+import { AVLTreeCounter, AVLTreeCounterNode, IBinaryTree } from '../../../../src';
 import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
@@ -619,14 +619,15 @@ describe('AVLTreeCounter iterative methods test', () => {
 
   it('The node obtained by get Node should match the node type', () => {
     const node3 = avlCounter.getNode(3);
-    expect(node3).toBeInstanceOf(BinaryTreeNode);
-    expect(node3).toBeInstanceOf(BSTNode);
-    expect(node3).toBeInstanceOf(AVLTreeNode);
+    // expect(node3).toBeInstanceOf(BinaryTreeNode);
+    // expect(node3).toBeInstanceOf(BSTNode);
+    // expect(node3).toBeInstanceOf(AVLTreeNode);
+    expect(node3).toBeInstanceOf(AVLTreeCounterNode);
   });
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    avlCounter.forEach((key, value) => {
+    avlCounter.forEach((value, key) => {
       mockCallback(key, value);
     });
 
@@ -637,7 +638,7 @@ describe('AVLTreeCounter iterative methods test', () => {
   });
 
   it('filter should return a new avlCounter with filtered elements', () => {
-    const filteredTree = avlCounter.filter(key => key > 1);
+    const filteredTree = avlCounter.filter((_value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [2, 'b'],
@@ -646,7 +647,7 @@ describe('AVLTreeCounter iterative methods test', () => {
   });
 
   it('map should return a new avlCounter with modified elements', () => {
-    const avlCounterMapped = avlCounter.map((key, value) => [(key * 2).toString(), value]);
+    const avlCounterMapped = avlCounter.map((value, key) => [(key * 2).toString(), value]);
     expect(avlCounterMapped.size).toBe(3);
     expect([...avlCounterMapped]).toEqual([
       ['2', 'a'],

package/test/unit/data-structures/binary-tree/avl-tree-multi-map.test.ts

@@ -415,7 +415,7 @@ describe('AVLTreeMultiMap iterative methods test', () => {
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    avlTmm.forEach((key, value) => {
+    avlTmm.forEach((value, key) => {
       mockCallback(key, value);
     });
 
@@ -426,7 +426,7 @@ describe('AVLTreeMultiMap iterative methods test', () => {
   });
 
   it('filter should return a new avlTmm with filtered elements', () => {
-    const filteredTree = avlTmm.filter(key => key > 1);
+    const filteredTree = avlTmm.filter((_value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [2, ['b']],
@@ -435,7 +435,7 @@ describe('AVLTreeMultiMap iterative methods test', () => {
   });
 
   it('map should return a new avlTmm with modified elements', () => {
-    const avlTmmMapped = avlTmm.map((key, value) => [(key * 2).toString(), value ? value : []]);
+    const avlTmmMapped = avlTmm.map((value, key) => [(key * 2).toString(), value ? value : []]);
     expect(avlTmmMapped.size).toBe(3);
     expect([...avlTmmMapped]).toEqual([
       ['2', ['a']],

package/test/unit/data-structures/binary-tree/avl-tree.test.ts

@@ -1,4 +1,4 @@
-import { AVLTree, AVLTreeNode, BinaryTreeNode, BSTNode, IBinaryTree } from '../../../../src';
+import { AVLTree, AVLTreeNode, IBinaryTree } from '../../../../src';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
@@ -379,14 +379,14 @@ describe('AVLTree iterative methods test', () => {
 
   it('The node obtained by get Node should match the node type', () => {
     const node3 = avlTree.getNode(3);
-    expect(node3).toBeInstanceOf(BinaryTreeNode);
-    expect(node3).toBeInstanceOf(BSTNode);
+    // expect(node3).toBeInstanceOf(BinaryTreeNode);
+    // expect(node3).toBeInstanceOf(BSTNode);
     expect(node3).toBeInstanceOf(AVLTreeNode);
   });
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    avlTree.forEach((key, value) => {
+    avlTree.forEach((value, key) => {
       mockCallback(key, value);
     });
 
@@ -397,7 +397,7 @@ describe('AVLTree iterative methods test', () => {
   });
 
   it('filter should return a new avlTree with filtered elements', () => {
-    const filteredTree = avlTree.filter(key => key > 1);
+    const filteredTree = avlTree.filter((_value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [2, 'b'],
@@ -406,7 +406,7 @@ describe('AVLTree iterative methods test', () => {
   });
 
   it('map should return a new avlTree with modified elements', () => {
-    const mappedTree = avlTree.map((key, value) => [(key * 2).toString(), value]);
+    const mappedTree = avlTree.map((value, key) => [(key * 2).toString(), value]);
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([
       ['2', 'a'],

package/test/unit/data-structures/binary-tree/binary-tree.test.ts

@@ -1308,7 +1308,7 @@ describe('BinaryTree (map mode) - higher-order & iteration', () => {
 
   it('forEach(): iterates all entries', () => {
     const mockCallback = jest.fn();
-    binaryTree.forEach((key, value) => {
+    binaryTree.forEach((value, key) => {
       mockCallback(key, value);
     });
 
@@ -1319,7 +1319,7 @@ describe('BinaryTree (map mode) - higher-order & iteration', () => {
   });
 
   it('filter(): returns new tree with filtered entries', () => {
-    const filteredTree = binaryTree.filter(key => key > 1);
+    const filteredTree = binaryTree.filter((_value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [3, 'c'],
@@ -1328,7 +1328,7 @@ describe('BinaryTree (map mode) - higher-order & iteration', () => {
   });
 
   it('map(): returns new tree with transformed keys/values', () => {
-    const mappedTree = binaryTree.map((key, value) => [(key * 2).toString(), value]);
+    const mappedTree = binaryTree.map((value, key) => [(key * 2).toString(), value]);
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([
       ['2', 'a'],
@@ -1578,7 +1578,7 @@ describe('Coverage boosters - close remaining uncovered branches', () => {
       [1, 'a'],
       [2, 'b']
     ]);
-    const mapped = t.map((k, v) => [String(k), (v ?? '').toUpperCase()], { iterationType: 'RECURSIVE' } as any);
+    const mapped = t.map((v, k) => [String(k), (v ?? '').toUpperCase()], { iterationType: 'RECURSIVE' } as any);
     expect(Array.from(mapped)).toEqual([
       ['1', 'A'],
       ['2', 'B']

package/test/unit/data-structures/binary-tree/bst.test.ts

@@ -1,4 +1,4 @@
-import { BinaryTreeNode, BST, BSTNode, IBinaryTree, Range } from '../../../../src';
+import { BST, BSTNode, IBinaryTree, Range } from '../../../../src';
 import { isDebugTest, isTestStackOverflow, SYSTEM_MAX_CALL_STACK } from '../../../config';
 
 const isDebug = isDebugTest;
@@ -1103,13 +1103,13 @@ describe('BST iterative methods test', () => {
 
   it('The node obtained by get Node should match the node type', () => {
     const node3 = bst.getNode(3);
-    expect(node3).toBeInstanceOf(BinaryTreeNode);
+    // expect(node3).toBeInstanceOf(BinaryTreeNode);
     expect(node3).toBeInstanceOf(BSTNode);
   });
 
   it('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    bst.forEach((key, value) => {
+    bst.forEach((value, key) => {
       mockCallback(key, value);
     });
 
@@ -1120,7 +1120,7 @@ describe('BST iterative methods test', () => {
   });
 
   it('filter should return a new tree with filtered elements', () => {
-    const filteredTree = bst.filter(key => key > 1);
+    const filteredTree = bst.filter((_value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([
       [2, 'b'],
@@ -1129,7 +1129,7 @@ describe('BST iterative methods test', () => {
   });
 
   it('map should return a new tree with modified elements', () => {
-    const mappedTree = bst.map((key, value) => [(key * 2).toString(), value]);
+    const mappedTree = bst.map((value, key) => [(key * 2).toString(), value]);
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([
       ['2', 'a'],