data-structure-typed 1.47.5 → 1.47.7

package/test/integration/index.html

@@ -215,6 +215,93 @@
   } catch (e) {
     console.error(e);
   }
+  
+  try {
+  const {
+      AVLTree,
+        BinaryTree,
+        BST,
+        Deque,
+        DoublyLinkedList,
+        HashMap,
+        Heap,
+        MaxPriorityQueue,
+        MinHeap,
+        MinPriorityQueue,
+        Queue,
+        RedBlackTree,
+        SinglyLinkedList,
+        Stack,
+        TreeMultimap,
+        Trie
+    } = dataStructureTyped;
+    const orgArr = [6, 1, 2, 7, 5, 3, 4, 9, 8];
+    const orgStrArr = ["trie", "trial", "trick", "trip", "tree", "trend", "triangle", "track", "trace", "transmit"];
+    const entries = [[6, 6], [1, 1], [2, 2], [7, 7], [5, 5], [3, 3], [4, 4], [9, 9], [8, 8]];
+
+    const queue = new Queue(orgArr);
+    queue.print();
+
+    const deque = new Deque(orgArr);
+    deque.print();
+
+    const sList = new SinglyLinkedList(orgArr);
+    sList.print();
+
+    const dList = new DoublyLinkedList(orgArr);
+    dList.print();
+
+    const stack = new Stack(orgArr);
+    stack.print();
+
+    const minHeap = new MinHeap(orgArr);
+    minHeap.print();
+
+    const maxPQ = new MaxPriorityQueue(orgArr);
+    maxPQ.print();
+
+    const biTree = new BinaryTree(entries);
+    biTree.print();
+
+    const bst = new BST(entries);
+    bst.print();
+
+    const rbTree = new RedBlackTree(entries);
+    rbTree.print();
+
+    const avl = new AVLTree(entries);
+    avl.print();
+
+    const treeMulti = new TreeMultimap(entries);
+    treeMulti.print();
+
+    const hm = new HashMap(entries);
+    hm.print()
+    const rbTreeH = new RedBlackTree(hm);
+    rbTreeH.print();
+
+    const pq = new MinPriorityQueue(orgArr);
+    pq.print();
+    const bst1 = new BST(pq);
+    bst1.print();
+
+    const dq1 = new Deque(orgArr);
+    dq1.print();
+    const rbTree1 = new RedBlackTree(dq1);
+    rbTree1.print();
+
+    const trie2 = new Trie(orgStrArr);
+    trie2.print();
+    const heap2 = new Heap(trie2, { comparator: (a, b) => Number(a) - Number(b) });
+    heap2.print();
+    const dq2 = new Deque(heap2);
+    dq2.print();
+    const entries2 = dq2.map((el, i) => [i, el]);
+    const avl2 = new AVLTree(entries2);
+    avl2.print();
+  }  catch (e) {
+    console.error(e);
+  }
 </script>
 
 </body>

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

@@ -23,17 +23,18 @@ const arrHundredThousand = getRandomIntArray(HUNDRED_THOUSAND, 0, HUNDRED_THOUSA
 suite
   .add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
 
-    const pq = new SRCPriorityQueue<number>({ comparator: (a, b) => b - a });
+    const pq = new SRCPriorityQueue<number>();
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
   })
   .add(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
 
-    const pq = new CJSPriorityQueue<number>({ comparator: (a, b) => b - a });
+
+    const pq = new CJSPriorityQueue<number>();
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
   })
   .add(`MJS PQ ${TEN_THOUSAND.toLocaleString()} add`, () => {
 
-    const pq = new MJSPriorityQueue<number>({ comparator: (a, b) => b - a });
+    const pq = new MJSPriorityQueue<number>([], { comparator: (a, b) => b - a });
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
   });
 
@@ -47,19 +48,19 @@ if (isCompetitor) {
 
 suite
   .add(`SRC PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
-    const pq = new SRCPriorityQueue<number>({ comparator: (a, b) => b - a });
+    const pq = new SRCPriorityQueue<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
     for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
   })
   .add(`CJS PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
-    const pq = new CJSPriorityQueue<number>({ comparator: (a, b) => b - a });
+    const pq = new CJSPriorityQueue<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
     for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();
   })
   .add(`MJS PQ ${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
-    const pq = new MJSPriorityQueue<number>({ comparator: (a, b) => b - a });
+    const pq = new MJSPriorityQueue<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < TEN_THOUSAND; i++) pq.add(i);
     for (let i = 0; i < TEN_THOUSAND; i++) pq.pop();

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

@@ -7,7 +7,7 @@ const { HUNDRED_THOUSAND, TEN_THOUSAND } = magnitude;
 
 suite
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
-    const heap = new Heap<number>({ comparator: (a, b) => b - a });
+    const heap = new Heap<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) {
       heap.add(i);
@@ -18,7 +18,7 @@ suite
     }
   })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & dfs`, () => {
-    const heap = new Heap<number>({ comparator: (a, b) => b - a });
+    const heap = new Heap<number>([], { comparator: (a, b) => b - a });
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) {
       heap.add(i);

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

@@ -8,7 +8,7 @@ const suite = new Benchmark.Suite();
 const { HUNDRED_THOUSAND } = magnitude;
 
 suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
-  const pq = new PriorityQueue<number>({ comparator: (a, b) => b - a });
+  const pq = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
 
   for (let i = 0; i < HUNDRED_THOUSAND; i++) {
     pq.add(i);

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

@@ -5,7 +5,7 @@ describe('AVL Tree Test', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
     const tree = new AVLTree<number>();
 
-    for (const i of arr) tree.add(i, i);
+    for (const i of arr) tree.add([i, i]);
 
     tree.add(null);
     const node6 = tree.getNode(6);
@@ -112,9 +112,9 @@ describe('AVL Tree Test', () => {
 describe('AVL Tree Test recursively', () => {
   it('should perform various operations on a AVL Tree', () => {
     const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    const tree = new AVLTree<number>({ iterationType: IterationType.RECURSIVE });
+    const tree = new AVLTree<number>([], { iterationType: IterationType.RECURSIVE });
 
-    for (const i of arr) tree.add(i, i);
+    for (const i of arr) tree.add([i, i]);
 
     const node6 = tree.getNode(6);
 
@@ -230,7 +230,7 @@ describe('AVLTree APIs test', () => {
     avl.add(node2);
     const node3 = new AVLTreeNode(3, { id: 3, text: 'text3' });
     avl.add(node3);
-    avl.add(node3, { id: 3, text: 'text33' });
+    avl.add([3, { id: 3, text: 'text33' }]);
 
     const bfsRes = avl.bfs(node => node.key);
     expect(bfsRes[0]).toBe(2);
@@ -240,26 +240,26 @@ describe('AVLTree APIs test', () => {
 describe('AVLTree', () => {
   it('should balance the tree using _balanceLR when nodes are added', () => {
     const avlTree = new AVLTree();
-    avlTree.add(10, 'A');
-    avlTree.add(5, 'B');
-    avlTree.add(15, 'C');
-    avlTree.add(3, 'D');
-    avlTree.add(7, 'E');
+    avlTree.add([10, 'A']);
+    avlTree.add([5, 'B']);
+    avlTree.add([15, 'C']);
+    avlTree.add([3, 'D']);
+    avlTree.add([7, 'E']);
 
     // Adding nodes to trigger _balanceLR
-    avlTree.add(12, 'F');
+    avlTree.add([12, 'F']);
 
     // You can add more specific assertions to check the tree's balance and structure.
   });
 
   it('should balance the tree using _balanceLR when nodes are deleted', () => {
     const avlTree = new AVLTree();
-    avlTree.add(10, 'A');
-    avlTree.add(5, 'B');
-    avlTree.add(15, 'C');
-    avlTree.add(3, 'D');
-    avlTree.add(7, 'E');
-    avlTree.add(12, 'F');
+    avlTree.add([10, 'A']);
+    avlTree.add([5, 'B']);
+    avlTree.add([15, 'C']);
+    avlTree.add([3, 'D']);
+    avlTree.add([7, 'E']);
+    avlTree.add([12, 'F']);
 
     // Deleting nodes to trigger _balanceLR
     avlTree.delete(3);
@@ -279,7 +279,7 @@ describe('AVLTree', () => {
       avl.add(node2);
       const node3 = new AVLTreeNode(3, { id: 3, text: 'text3' });
       avl.add(node3);
-      avl.add(node3, { id: 3, text: 'text33' });
+      avl.add([3, { id: 3, text: 'text33' }]);
 
       const bfsRes = avl.bfs(node => node);
       expect(bfsRes[0]?.key).toBe(2);
@@ -291,9 +291,9 @@ describe('AVLTree iterative methods test', () => {
   let avl: AVLTree<string>;
   beforeEach(() => {
     avl = new AVLTree();
-    avl.add(1, 'a');
-    avl.add(2, 'b');
-    avl.add(3, 'c');
+    avl.add([1, 'a']);
+    avl.add([2, 'b']);
+    avl.add([3, 'c']);
   });
 
   test('The node obtained by get Node should match the node type', () => {

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

@@ -1,6 +1,5 @@
-import { BinaryTree, BinaryTreeNode, IterationType } from '../../../../src';
+import { BinaryTree, BinaryTreeNode, FamilyPosition, IterationType } from '../../../../src';
 import { getRandomIntArray } from '../../../utils';
-import { FamilyPosition } from 'binary-tree-typed';
 // import {isDebugTest} from '../../../config';
 
 // const isDebug = isDebugTest;
@@ -137,10 +136,10 @@ describe('BinaryTree', () => {
   });
 
   it('should add and find nodes', () => {
-    tree.add(1, 1);
+    tree.add([1, 1]);
     tree.add(undefined);
-    tree.add(2, 2);
-    tree.add(3, 3);
+    tree.add([2, 2]);
+    tree.add([3, 3]);
 
     expect(tree.has(1)).toBe(true);
     expect(tree.has(2)).toBe(true);
@@ -189,9 +188,9 @@ describe('BinaryTree', () => {
     tree.add(4);
     tree.add(2);
     expect(tree.getHeight()).toBe(1);
-    tree.options.iterationType = IterationType.RECURSIVE;
+    tree.iterationType = IterationType.RECURSIVE;
     expect(tree.getHeight()).toBe(1);
-    tree.options.iterationType = IterationType.ITERATIVE;
+    tree.iterationType = IterationType.ITERATIVE;
 
     tree.add(6);
     tree.add(1);
@@ -381,7 +380,7 @@ describe('BinaryTree', () => {
   let tree: BinaryTree<string>;
 
   beforeEach(() => {
-    tree = new BinaryTree<string>({ iterationType: IterationType.RECURSIVE });
+    tree = new BinaryTree<string>([], { iterationType: IterationType.RECURSIVE });
   });
 
   afterEach(() => {
@@ -395,9 +394,9 @@ describe('BinaryTree', () => {
   });
 
   it('should add nodes to the tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.size).toBe(3);
     expect(tree.isEmpty()).toBe(false);
@@ -405,9 +404,9 @@ describe('BinaryTree', () => {
   });
 
   it('should clear the BinaryTree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     tree.clear();
 
@@ -417,9 +416,9 @@ describe('BinaryTree', () => {
   });
 
   it('should get nodes by key', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const nodeA = tree.getNode(5);
     const nodeB = tree.getNode(3);
@@ -431,7 +430,7 @@ describe('BinaryTree', () => {
   });
 
   it('should return null when getting a non-existent node', () => {
-    tree.add(5, 'A');
+    tree.add([5, 'A']);
 
     const node = tree.getNode(3);
 
@@ -439,18 +438,18 @@ describe('BinaryTree', () => {
   });
 
   it('should get the depth of a node', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.getDepth(7)).toBe(1);
     expect(tree.getDepth(3)).toBe(1);
   });
 
   it('should get the height of the tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.getHeight()).toBe(1);
     expect(tree.getHeight(undefined, IterationType.RECURSIVE)).toBe(1);
@@ -458,17 +457,17 @@ describe('BinaryTree', () => {
   });
 
   it('should check if the tree is a binary search tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.isBST()).toBe(true);
   });
 
   it('should perform a depth-first traversal', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const result = tree.dfs();
     expect(result).toEqual([3, 5, 7]);
@@ -476,9 +475,9 @@ describe('BinaryTree', () => {
   });
 
   it('should perform a breadth-first traversal', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const result = tree.bfs(node => node.key);
     expect(result).toEqual([5, 3, 7]);
@@ -486,9 +485,9 @@ describe('BinaryTree', () => {
   });
 
   it('should list levels of the tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const levels = tree.listLevels();
     expect(levels).toEqual([[5], [3, 7]]);
@@ -496,9 +495,9 @@ describe('BinaryTree', () => {
   });
 
   it('should delete nodes from the tree', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     tree.delete(3);
 
@@ -507,17 +506,17 @@ describe('BinaryTree', () => {
   });
 
   it('should check if the tree is perfectly balanced', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     expect(tree.isPerfectlyBalanced()).toBe(true);
   });
 
   it('should get nodes by a custom callback', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     const nodes = tree.getNodes('B', (node: BinaryTreeNode<string>) => node.value);
 
@@ -537,15 +536,15 @@ describe('BinaryTree', () => {
   });
 
   it('should perform Morris traversal', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
-    tree.options.iterationType = IterationType.ITERATIVE;
+    tree.iterationType = IterationType.ITERATIVE;
     expect([...tree]).toEqual([[3, "B"], [5, "A"], [7, "C"]]);
-    tree.options.iterationType = IterationType.RECURSIVE;
+    tree.iterationType = IterationType.RECURSIVE;
     expect([...tree]).toEqual([[3, "B"], [5, "A"], [7, "C"]]);
-    tree.options.iterationType = IterationType.ITERATIVE;
+    tree.iterationType = IterationType.ITERATIVE;
 
     const result = tree.morris();
     expect(result).toEqual([3, 5, 7]);
@@ -553,9 +552,9 @@ describe('BinaryTree', () => {
   });
 
   it('should perform delete all', () => {
-    tree.add(5, 'A');
-    tree.add(3, 'B');
-    tree.add(7, 'C');
+    tree.add([5, 'A']);
+    tree.add([3, 'B']);
+    tree.add([7, 'C']);
 
     tree.delete(5);
     tree.delete(7);
@@ -570,9 +569,9 @@ describe('BinaryTree iterative methods test', () => {
   let binaryTree: BinaryTree<string>;
   beforeEach(() => {
     binaryTree = new BinaryTree();
-    binaryTree.add(1, 'a');
-    binaryTree.add(2, 'b');
-    binaryTree.add(3, 'c');
+    binaryTree.add([1, 'a']);
+    binaryTree.add([2, 'b']);
+    binaryTree.add([3, 'c']);
   });
 
   test('The node obtained by get Node should match the node type', () => {

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

@@ -7,10 +7,10 @@ describe('BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
     const bst = new BST();
     expect(bst).toBeInstanceOf(BST);
-    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, idsAndValues, false);
+    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);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
     if (bst.root) expect(bst.root.key).toBe(11);
@@ -191,30 +191,26 @@ describe('BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
-    objBST.add(11, { key: 11, keyA: 11 });
-    objBST.add(3, { key: 3, keyA: 3 });
-    const values = [
-      { key: 15, keyA: 15 },
-      { key: 1, keyA: 1 },
-      { key: 8, keyA: 8 },
-      { key: 13, keyA: 13 },
-      { key: 16, keyA: 16 },
-      { key: 2, keyA: 2 },
-      { key: 6, keyA: 6 },
-      { key: 9, keyA: 9 },
-      { key: 12, keyA: 12 },
-      { key: 14, keyA: 14 },
-      { key: 4, keyA: 4 },
-      { key: 7, keyA: 7 },
-      { key: 10, keyA: 10 },
-      { key: 5, keyA: 5 }
+    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.map(item => item.key),
-      values,
-      false
-    );
+    objBST.addMany(values, false);
 
     expect(objBST.root).toBeInstanceOf(BSTNode);
 
@@ -395,12 +391,12 @@ describe('BST operations test', () => {
 
 describe('BST operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
-    const bst = new BST({ iterationType: IterationType.RECURSIVE });
+    const bst = new BST<number>([], { iterationType: IterationType.RECURSIVE });
     expect(bst).toBeInstanceOf(BST);
-    bst.add(11, 11);
-    bst.add(3, 3);
+    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, idsAndValues, false);
+    bst.addMany(idsAndValues, false);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
     if (bst.root) expect(bst.root.key).toBe(11);
@@ -414,11 +410,11 @@ describe('BST operations test recursively', () => {
     expect(node6 && bst.getDepth(6)).toBe(3);
 
     const nodeId10 = bst.getNode(10);
-    expect(bst.get(10)).toBe(10);
+    expect(bst.get(10)).toBe(undefined);
     expect(nodeId10?.key).toBe(10);
 
     const nodeVal9 = bst.getNode(9, node => node.value);
-    expect(nodeVal9?.key).toBe(9);
+    expect(nodeVal9?.key).toBe(undefined);
 
     const leftMost = bst.getLeftMost();
     expect(leftMost?.key).toBe(1);
@@ -582,27 +578,26 @@ describe('BST operations test recursively', () => {
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
-    objBST.add(11, { key: 11, keyA: 11 });
-    objBST.add(3, { key: 3, keyA: 3 });
-    const values = [
-      { key: 15, keyA: 15 },
-      { key: 1, keyA: 1 },
-      { key: 8, keyA: 8 },
-      { key: 13, keyA: 13 },
-      { key: 16, keyA: 16 },
-      { key: 2, keyA: 2 },
-      { key: 6, keyA: 6 },
-      { key: 9, keyA: 9 },
-      { key: 12, keyA: 12 },
-      { key: 14, keyA: 14 },
-      { key: 4, keyA: 4 },
-      { key: 7, keyA: 7 },
-      { key: 10, keyA: 10 },
-      { key: 5, keyA: 5 }
+    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.map(item => item.key),
       values,
       false
     );
@@ -834,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], undefined, false);
+    bst.addMany([9, 8, 7, 3, 1, 2, 5, 4, 6], false);
     expect(bst.lastKey()).toBe(9);
   });
 
@@ -856,9 +851,9 @@ describe('BST iterative methods test', () => {
   let bst: BST<string>;
   beforeEach(() => {
     bst = new BST();
-    bst.add(1, 'a');
-    bst.add(2, 'b');
-    bst.add(3, 'c');
+    bst.add([1, 'a']);
+    bst.add([2, 'b']);
+    bst.add([3, 'c']);
   });
 
   test('The node obtained by get Node should match the node type', () => {