data-structure-typed 1.48.5 → 1.48.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "data-structure-typed",
-  "version": "1.48.5",
-  "description": "Data Structures of Javascript & TypeScript. Heap, Binary Tree, RedBlack Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack.",
+  "version": "1.48.6",
+  "description": "Data Structures of Javascript & TypeScript. Heap, Binary Tree, Red Black Tree, Linked List, Deque, Trie, HashMap, Directed Graph, Undirected Graph, Binary Search Tree(BST), AVL Tree, Priority Queue, Graph, Queue, Tree Multiset, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue, Stack. Benchmark compared with C++ STL. API aligned with ES6 and Java. Usability is comparable to Python",
   "main": "dist/cjs/index.js",
   "module": "dist/mjs/index.js",
   "types": "dist/mjs/index.d.ts",

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

@@ -99,7 +99,7 @@ export class AVLTree<K = any, V = any, N extends AVLTreeNode<K, V, N> = AVLTreeN
   /**
    * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
    * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
-   * 
+   *
    * The function overrides the add method of a binary tree node and balances the tree after inserting
    * a new node.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an

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

@@ -235,7 +235,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
   /**
    * Time Complexity O(log n) - O(n)
    * Space Complexity O(1)
-   * 
+   *
    * The `add` function adds a new node to a binary tree, either by creating a new node or replacing an
    * existing node with the same key.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
@@ -288,22 +288,38 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
    * Time Complexity: O(k log n) - O(k * n)
    * Space Complexity: O(1)
    *
-   * The function `addMany` takes in an iterable of `BTNodeExemplar` objects, adds each object to the
-   * current instance, and returns an array of the inserted nodes.
-   * @param nodes - The `nodes` parameter is an iterable (such as an array or a set) of
-   * `BTNodeExemplar<K, V,N>` objects.
-   * @returns The function `addMany` returns an array of values, where each value is either of type
-   * `N`, `null`, or `undefined`.
-   */
-  addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>): (N | null | undefined)[] {
+   * The `addMany` function takes in a collection of nodes and an optional collection of values, and
+   * adds each node with its corresponding value to the data structure.
+   * @param nodes - An iterable collection of BTNodeExemplar objects.
+   * @param [values] - An optional iterable of values that will be assigned to each node being added.
+   * @returns The function `addMany` returns an array of `N`, `null`, or `undefined` values.
+   */
+  addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[] {
     // TODO not sure addMany not be run multi times
     const inserted: (N | null | undefined)[] = [];
+
+    let valuesIterator: Iterator<V | undefined> | undefined;
+    if (values) {
+      valuesIterator = values[Symbol.iterator]();
+    }
+
     for (const kne of nodes) {
-      inserted.push(this.add(kne));
+      let value: V | undefined | null = undefined;
+
+      if (valuesIterator) {
+        const valueResult = valuesIterator.next();
+        if (!valueResult.done) {
+          value = valueResult.value;
+        }
+      }
+
+      inserted.push(this.add(kne, value));
     }
+
     return inserted;
   }
 
+
   /**
    * Time Complexity: O(k * n)  "n" is the number of nodes in the tree, and "k" is the number of keys to be inserted.
    * Space Complexity: O(1)

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

@@ -192,7 +192,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
   /**
    * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
    * Space Complexity: O(1) - Constant space is used.
-   * 
+   *
    * The `add` function adds a new node to a binary tree, updating the value if the key already exists
    * or inserting a new node if the key is unique.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can accept three types of values:
@@ -256,31 +256,45 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
    * Time Complexity: O(k log n) - Adding each element individually in a balanced tree.
    * Space Complexity: O(k) - Additional space is required for the sorted array.
    *
-   * The `addMany` function in TypeScript adds multiple nodes to a binary tree, either in a balanced or
-   * unbalanced manner, and returns an array of the inserted nodes.
-   * @param keysOrNodesOrEntries - An iterable containing keys, nodes, or entries to be added to the
-   * binary tree.
-   * @param [isBalanceAdd=true] - A boolean flag indicating whether the tree should be balanced after
-   * adding the nodes. The default value is true.
+   * The `addMany` function in TypeScript adds multiple keys or nodes to a binary tree, optionally
+   * balancing the tree after each addition.
+   * @param keysOrNodesOrEntries - An iterable containing the keys, nodes, or entries to be added to
+   * the binary tree.
+   * @param [values] - An optional iterable of values to be associated with the keys or nodes being
+   * added. If provided, the values will be assigned to the corresponding keys or nodes in the same
+   * order. If not provided, undefined will be assigned as the value for each key or node.
+   * @param [isBalanceAdd=true] - A boolean flag indicating whether the add operation should be
+   * balanced or not. If set to true, the add operation will be balanced using a binary search tree
+   * algorithm. If set to false, the add operation will not be balanced and the elements will be added
+   * in the order they appear in the input.
    * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
-   * type of iteration to use when adding multiple keys or nodes to the binary tree. It has a default
-   * value of `this.iterationType`, which means it will use the iteration type specified by the binary
-   * tree instance.
-   * @returns The `addMany` function returns an array of `N` or `undefined` values.
+   * type of iteration to use when adding multiple keys or nodes. It has a default value of
+   * `this.iterationType`, which suggests that it is a property of the current object.
+   * @returns The function `addMany` returns an array of nodes (`N`) or `undefined` values.
    */
   override addMany(
     keysOrNodesOrEntries: Iterable<BTNodeExemplar<K, V, N>>,
+    values?: Iterable<V | undefined>,
     isBalanceAdd = true,
     iterationType = this.iterationType
   ): (N | undefined)[] {
-    const inserted: (N | undefined)[] = []
+    const inserted: (N | undefined)[] = [];
+
+    let valuesIterator: Iterator<V | undefined> | undefined;
+
+    if (values) {
+      valuesIterator = values[Symbol.iterator]();
+    }
+
     if (!isBalanceAdd) {
       for (const kve of keysOrNodesOrEntries) {
-        const nn = this.add(kve)
+        const value = valuesIterator?.next().value;
+        const nn = this.add(kve, value);
         inserted.push(nn);
       }
       return inserted;
     }
+
     const realBTNExemplars: BTNodePureExemplar<K, V, N>[] = [];
 
     const isRealBTNExemplar = (kve: BTNodeExemplar<K, V, N>): kve is BTNodePureExemplar<K, V, N> => {
@@ -292,22 +306,20 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
       isRealBTNExemplar(kve) && realBTNExemplars.push(kve);
     }
 
-    // TODO this addMany function is inefficient, it should be optimized
     let sorted: BTNodePureExemplar<K, V, N>[] = [];
 
     sorted = realBTNExemplars.sort((a, b) => {
       let aR: number, bR: number;
-      if (this.isEntry(a)) aR = this.extractor(a[0])
-      else if (this.isRealNode(a)) aR = this.extractor(a.key)
+      if (this.isEntry(a)) aR = this.extractor(a[0]);
+      else if (this.isRealNode(a)) aR = this.extractor(a.key);
       else aR = this.extractor(a);
 
-      if (this.isEntry(b)) bR = this.extractor(b[0])
-      else if (this.isRealNode(b)) bR = this.extractor(b.key)
+      if (this.isEntry(b)) bR = this.extractor(b[0]);
+      else if (this.isRealNode(b)) bR = this.extractor(b.key);
       else bR = this.extractor(b);
 
       return aR - bR;
-    })
-
+    });
 
     const _dfs = (arr: BTNodePureExemplar<K, V, N>[]) => {
       if (arr.length === 0) return;
@@ -318,6 +330,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
       _dfs(arr.slice(0, mid));
       _dfs(arr.slice(mid + 1));
     };
+
     const _iterate = () => {
       const n = sorted.length;
       const stack: [[number, number]] = [[0, n - 1]];
@@ -335,6 +348,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
         }
       }
     };
+
     if (iterationType === IterationType.RECURSIVE) {
       _dfs(sorted);
     } else {
@@ -344,6 +358,7 @@ export class BST<K = any, V = any, N extends BSTNode<K, V, N> = BSTNode<K, V, BS
     return inserted;
   }
 
+
   // /**
   //  * Time Complexity: O(n log n) - Adding each element individually in a balanced tree.
   //  * Space Complexity: O(n) - Additional space is required for the sorted array.

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

@@ -153,7 +153,7 @@ export class RedBlackTree<K = any, V = any, N extends RedBlackTreeNode<K, V, N>
   /**
    * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
    * Space Complexity: O(1)
-   * 
+   *
    * The `add` function adds a new node to a binary search tree and performs necessary rotations and
    * color changes to maintain the red-black tree properties.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an

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

@@ -126,7 +126,7 @@ export class TreeMultimap<K = any, V = any, N extends TreeMultimapNode<K, V, N>
   /**
    * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
    * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
-   * 
+   *
    * The function overrides the add method of a binary tree node and adds a new node to the tree.
    * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be either a key, a node, or an
    * entry. It represents the key, node, or entry that you want to add to the binary tree.

package/src/interfaces/binary-tree.ts

@@ -15,7 +15,7 @@ export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V,
 
   add(keyOrNodeOrEntry: BTNodeExemplar<K, V, N>, value?: V, count?: number): N | null | undefined;
 
-  addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>): (N | null | undefined)[];
+  addMany(nodes: Iterable<BTNodeExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
 
   delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BiTreeDeleteResult<N>[];
 }

package/test/performance/data-structures/binary-tree/rb-tree.test.ts

@@ -18,7 +18,7 @@ suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
 });
 
 if (isCompetitor) {
-  suite.add(`${HUNDRED_THOUSAND.toLocaleString()} CPT add`, () => {
+  suite.add(`CPT ${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
     for (let i = 0; i < arr.length; i++) {
       cOrderedMap.setElement(arr[i], arr[i]);
     }

package/test/performance/data-structures/hash/hash-map.test.ts

@@ -16,7 +16,7 @@ suite.add(`${MILLION.toLocaleString()} set`, () => {
 });
 
 if (isCompetitor) {
-  suite.add(`${MILLION.toLocaleString()} CPT set`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} set`, () => {
     const hm = new CHashMap<number, number>();
 
     for (let i = 0; i < MILLION; i++) {
@@ -25,13 +25,13 @@ if (isCompetitor) {
   });
 }
 
-suite.add(`${MILLION.toLocaleString()} Map set`, () => {
+suite.add(`Native Map ${MILLION.toLocaleString()} set`, () => {
   const hm = new Map<number, number>();
 
   for (let i = 0; i < MILLION; i++) hm.set(i, i);
 });
 
-suite.add(`${MILLION.toLocaleString()} Set add`, () => {
+suite.add(`Native Set ${MILLION.toLocaleString()} add`, () => {
   const hs = new Set<number>();
 
   for (let i = 0; i < MILLION; i++) hs.add(i);
@@ -49,7 +49,7 @@ suite.add(`${MILLION.toLocaleString()} set & get`, () => {
 });
 
 if (isCompetitor) {
-  suite.add(`${MILLION.toLocaleString()} CPT set & get`, () => {
+  suite.add(`CPT ${MILLION.toLocaleString()} set & get`, () => {
     const hm = new CHashMap<number, number>();
 
     for (let i = 0; i < MILLION; i++) {
@@ -61,7 +61,7 @@ if (isCompetitor) {
   });
 }
 
-suite.add(`${MILLION.toLocaleString()} Map set & get`, () => {
+suite.add(`Native Map ${MILLION.toLocaleString()} set & get`, () => {
   const hm = new Map<number, number>();
 
   for (let i = 0; i < MILLION; i++) {
@@ -72,7 +72,7 @@ suite.add(`${MILLION.toLocaleString()} Map set & get`, () => {
   }
 });
 
-suite.add(`${MILLION.toLocaleString()} Set add & has`, () => {
+suite.add(`Native Set ${MILLION.toLocaleString()} add & has`, () => {
   const hs = new Set<number>();
 
   for (let i = 0; i < MILLION; i++) hs.add(i);
@@ -94,7 +94,7 @@ suite.add(`${MILLION.toLocaleString()} ObjKey set & get`, () => {
   }
 });
 
-suite.add(`${MILLION.toLocaleString()} Map ObjKey set & get`, () => {
+suite.add(`Native Map ${MILLION.toLocaleString()} ObjKey set & get`, () => {
   const hm = new Map<[number, number], number>();
   const objs: [number, number][] = [];
   for (let i = 0; i < MILLION; i++) {
@@ -107,7 +107,7 @@ suite.add(`${MILLION.toLocaleString()} Map ObjKey set & get`, () => {
   }
 });
 
-suite.add(`${MILLION.toLocaleString()} Set ObjKey add & has`, () => {
+suite.add(`Native Set ${MILLION.toLocaleString()} ObjKey add & has`, () => {
   const hs = new Set<[number, number]>();
   const objs: [number, number][] = [];
   for (let i = 0; i < MILLION; i++) {

package/test/performance/data-structures/linked-list/doubly-linked-list.test.ts

@@ -17,7 +17,7 @@ suite.add(`${LINEAR.toLocaleString()} push`, () => {
 
 
 if (isCompetitor) {
-  suite.add(`${LINEAR.toLocaleString()} CPT push`, () => {
+  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
     const list = new CLinkedList<number>();
 
     for (let i = 0; i < LINEAR; i++) {
@@ -35,7 +35,7 @@ suite.add(`${LINEAR.toLocaleString()} unshift`, () => {
 });
 
 if (isCompetitor) {
-  suite.add(`${LINEAR.toLocaleString()} CPT unshift`, () => {
+  suite.add(`CPT ${LINEAR.toLocaleString()} unshift`, () => {
     const list = new CLinkedList<number>();
 
     for (let i = 0; i < LINEAR; i++) {

package/test/performance/data-structures/linked-list/singly-linked-list.test.ts

@@ -3,9 +3,20 @@ import * as Benchmark from 'benchmark';
 import { magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const { TEN_THOUSAND } = magnitude;
+const { MILLION, TEN_THOUSAND } = magnitude;
 
 suite
+  .add(`${MILLION.toLocaleString()} push & shift`, () => {
+    const list = new SinglyLinkedList<number>();
+
+    for (let i = 0; i < MILLION; i++) {
+      list.push(i);
+    }
+
+    for (let i = 0; i < MILLION; i++) {
+      list.shift();
+    }
+  })
   .add(`${TEN_THOUSAND.toLocaleString()} push & pop`, () => {
     const list = new SinglyLinkedList<number>();
 

package/test/performance/data-structures/priority-queue/priority-queue.test.ts

@@ -19,7 +19,7 @@ suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
   }
 });
 if (isCompetitor) {
-  suite.add(`${HUNDRED_THOUSAND.toLocaleString()} CPT add & pop`, () => {
+  suite.add(`CPT ${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
     const pq = new CPriorityQueue<number>();
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) {

package/test/performance/data-structures/queue/deque.test.ts

@@ -5,7 +5,7 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 export const suite = new Benchmark.Suite();
-const { LINEAR } = magnitude;
+const { LINEAR, HUNDRED_THOUSAND } = magnitude;
 
 suite.add(`${LINEAR.toLocaleString()} push`, () => {
   const deque = new Deque<number>();
@@ -13,7 +13,7 @@ suite.add(`${LINEAR.toLocaleString()} push`, () => {
 });
 
 if (isCompetitor) {
-  suite.add(`${LINEAR.toLocaleString()} CPT push`, () => {
+  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
     const _deque = new CDeque<number>();
     for (let i = 0; i < LINEAR; i++) _deque.pushBack(i);
   });
@@ -26,16 +26,28 @@ suite.add(`${LINEAR.toLocaleString()} push & pop`, () => {
   for (let i = 0; i < LINEAR; i++) _deque.push(i);
   for (let i = 0; i < LINEAR; i++) _deque.pop();
 
-});
-suite.add(`${LINEAR.toLocaleString()} push & shift`, () => {
-  const _deque = new Deque<number>();
-
-  for (let i = 0; i < LINEAR; i++) _deque.push(i);
-  for (let i = 0; i < LINEAR; i++) _deque.shift();
-});
-suite.add(`${LINEAR.toLocaleString()} unshift & shift`, () => {
-  const _deque = new Deque<number>();
-
-  for (let i = 0; i < LINEAR; i++) _deque.unshift(i);
-  for (let i = 0; i < LINEAR; i++) _deque.shift();
-});
+})
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
+    const _deque = new Deque<number>();
+
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) _deque.push(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) _deque.shift();
+  })
+  .add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
+    const _deque = new Array<number>();
+
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) _deque.push(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) _deque.shift();
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} unshift & shift`, () => {
+    const _deque = new Deque<number>();
+
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) _deque.unshift(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) _deque.shift();
+  })
+  .add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} unshift & shift`, () => {
+    const _deque = new Array<number>();
+
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) _deque.unshift(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) _deque.shift();
+  });

package/test/performance/data-structures/queue/queue.test.ts

@@ -5,7 +5,7 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { LINEAR } = magnitude;
+const { LINEAR, HUNDRED_THOUSAND } = magnitude;
 
 suite.add(`${LINEAR.toLocaleString()} push`, () => {
   const queue = new Queue<number>();
@@ -15,7 +15,7 @@ suite.add(`${LINEAR.toLocaleString()} push`, () => {
   }
 });
 if (isCompetitor) {
-  suite.add(`${LINEAR.toLocaleString()} CPT push`, () => {
+  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
     const queue = new CQueue<number>();
 
     for (let i = 0; i < LINEAR; i++) {
@@ -23,13 +23,36 @@ if (isCompetitor) {
     }
   });
 }
-suite.add(`${LINEAR.toLocaleString()} push & shift`, () => {
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
   const queue = new Queue<number>();
 
-  for (let i = 0; i < LINEAR; i++) {
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
     queue.push(i);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
     queue.shift();
   }
 });
+suite.add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
+  const arr = new Array<number>();
+
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    arr.push(i);
+  }
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+    arr.shift();
+  }
+})
+  .add(`Native Array ${HUNDRED_THOUSAND.toLocaleString()} push & pop`, () => {
+    const arr = new Array<number>();
+
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+      arr.push(i);
+    }
+
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
+      arr.pop();
+    }
+  });
 
 export { suite };

package/test/performance/data-structures/stack/stack.test.ts

@@ -15,7 +15,7 @@ suite.add(`${LINEAR.toLocaleString()} push`, () => {
   }
 });
 if (isCompetitor) {
-  suite.add(`${LINEAR.toLocaleString()} CPT push`, () => {
+  suite.add(`CPT ${LINEAR.toLocaleString()} push`, () => {
     const queue = new CStack<number>();
 
     for (let i = 0; i < LINEAR; i++) {
@@ -34,7 +34,7 @@ suite.add(`${LINEAR.toLocaleString()} push & pop`, () => {
   }
 });
 if (isCompetitor) {
-  suite.add(`${LINEAR.toLocaleString()} CPT push & pop`, () => {
+  suite.add(`CPT ${LINEAR.toLocaleString()} push & pop`, () => {
     const queue = new CStack<number>();
 
     for (let i = 0; i < LINEAR; i++) {

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

@@ -10,7 +10,7 @@ describe('BST operations test', () => {
     bst.add([11, 11]);
     bst.add([3, 3]);
     const idsAndValues: [number, number][] = [[15, 15], [1, 1], [8, 8], [13, 13], [16, 16], [2, 2], [6, 6], [9, 9], [12, 12], [14, 14], [4, 4], [7, 7], [10, 10], [5, 5]];
-    bst.addMany(idsAndValues, false);
+    bst.addMany(idsAndValues, undefined, false);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
     if (bst.root) expect(bst.root.key).toBe(11);
@@ -189,28 +189,27 @@ describe('BST operations test', () => {
   });
 
   it('should perform various operations on a Binary Search Tree with object values', () => {
-    const objBST = new BST<number, { key: number; keyA: number }>();
+    const objBST = new BST<number, { name: string; age: number }>();
     expect(objBST).toBeInstanceOf(BST);
-    objBST.add([11, { key: 11, keyA: 11 }]);
-    objBST.add([3, { key: 3, keyA: 3 }]);
-    const values: [number, { key: number; keyA: number }][] = [
-      [15, { key: 15, keyA: 15 }],
-      [1, { key: 1, keyA: 1 }],
-      [8, { key: 8, keyA: 8 }],
-      [13, { key: 13, keyA: 13 }],
-      [16, { key: 16, keyA: 16 }],
-      [2, { key: 2, keyA: 2 }],
-      [6, { key: 6, keyA: 6 }],
-      [9, { key: 9, keyA: 9 }],
-      [12, { key: 12, keyA: 12 }],
-      [14, { key: 14, keyA: 14 }],
-      [4, { key: 4, keyA: 4 }],
-      [7, { key: 7, keyA: 7 }],
-      [10, { key: 10, keyA: 10 }],
-      [5, { key: 5, keyA: 5 }]
-    ];
-
-    objBST.addMany(values, false);
+    objBST.add([11, { name: '11', age: 11 }]);
+    objBST.add([3, { name: '3', age: 3 }]);
+
+    objBST.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], [
+      { "name": "Alice", "age": 15 },
+      { "name": "Bob", "age": 1 },
+      { "name": "Charlie", "age": 8 },
+      { "name": "David", "age": 13 },
+      { "name": "Emma", "age": 16 },
+      { "name": "Frank", "age": 2 },
+      { "name": "Grace", "age": 6 },
+      { "name": "Hannah", "age": 9 },
+      { "name": "Isaac", "age": 12 },
+      { "name": "Jack", "age": 14 },
+      { "name": "Katie", "age": 4 },
+      { "name": "Liam", "age": 7 },
+      { "name": "Mia", "age": 10 },
+      { "name": "Noah", "age": 5 }
+    ], false);
 
     expect(objBST.root).toBeInstanceOf(BSTNode);
 
@@ -232,7 +231,7 @@ describe('BST operations test', () => {
     expect(leftMost?.key).toBe(1);
 
     const node15 = objBST.getNode(15);
-    expect(node15?.value).toEqual({ key: 15, keyA: 15 });
+    expect(node15?.value).toEqual({ name: 'Alice', age: 15 });
     const minNodeBySpecificNode = node15 && objBST.getLeftMost(node15);
     expect(minNodeBySpecificNode?.key).toBe(12);
 
@@ -256,7 +255,7 @@ describe('BST operations test', () => {
     objBST.perfectlyBalance();
     expect(objBST.isPerfectlyBalanced()).toBe(true);
 
-    const bfsNodesAfterBalanced: BSTNode<number, { key: number; keyA: number }>[] = [];
+    const bfsNodesAfterBalanced: BSTNode<number, { name: string; age: number }>[] = [];
     objBST.bfs(node => bfsNodesAfterBalanced.push(node));
     expect(bfsNodesAfterBalanced[0].key).toBe(8);
     expect(bfsNodesAfterBalanced[bfsNodesAfterBalanced.length - 1].key).toBe(16);
@@ -381,7 +380,7 @@ describe('BST operations test', () => {
     expect(bfsIDs[1]).toBe(12);
     expect(bfsIDs[2]).toBe(16);
 
-    const bfsNodes: BSTNode<number, { key: number; keyA: number }>[] = [];
+    const bfsNodes: BSTNode<number, { name: string; age: number }>[] = [];
     objBST.bfs(node => bfsNodes.push(node));
     expect(bfsNodes[0].key).toBe(2);
     expect(bfsNodes[1].key).toBe(12);
@@ -396,7 +395,7 @@ describe('BST operations test recursively', () => {
     bst.add([11, 11]);
     bst.add([3, 3]);
     const idsAndValues = [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    bst.addMany(idsAndValues, false);
+    bst.addMany(idsAndValues, undefined, false);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
     if (bst.root) expect(bst.root.key).toBe(11);
@@ -580,7 +579,7 @@ describe('BST operations test recursively', () => {
     expect(objBST).toBeInstanceOf(BST);
     objBST.add([11, { key: 11, keyA: 11 }]);
     objBST.add([3, { key: 3, keyA: 3 }]);
-    const values: [number, { key: number; keyA: number }][] = [
+    const entries: [number, { key: number; keyA: number }][] = [
       [15, { key: 15, keyA: 15 }],
       [1, { key: 1, keyA: 1 }],
       [8, { key: 8, keyA: 8 }],
@@ -598,7 +597,8 @@ describe('BST operations test recursively', () => {
     ];
 
     objBST.addMany(
-      values,
+      entries,
+      undefined,
       false
     );
 
@@ -829,7 +829,7 @@ describe('BST Performance test', function () {
 
   it('should the lastKey of a BST to be the largest key', function () {
     const bst = new BST();
-    bst.addMany([9, 8, 7, 3, 1, 2, 5, 4, 6], false);
+    bst.addMany([9, 8, 7, 3, 1, 2, 5, 4, 6], undefined, false);
     // TODO
     // expect(bst.lastKey()).toBe(9);
   });

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

@@ -5,7 +5,7 @@ describe('Overall BinaryTree Test', () => {
     const bst = new BST();
     bst.add(11);
     bst.add(3);
-    bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], false);
+    bst.addMany([15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5], undefined, false);
     bst.size === 16; // true
     expect(bst.size).toBe(16); // true
     bst.has(6); // true