data-structure-typed 1.48.5 → 1.48.7

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

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

@@ -32,7 +32,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(3);
       const popped = list.pop();
       expect(popped).toBe(3);
-      expect(list.popLast()).toBe(2);
+      expect(list.pollLast()).toBe(2);
       expect(list.toArray()).toEqual([1]);
     });
 
@@ -49,7 +49,7 @@ describe('SinglyLinkedList Operation Test', () => {
       list.push(3);
       const shifted = list.shift();
       expect(shifted).toBe(1);
-      expect(list.popFirst()).toBe(2);
+      expect(list.pollFirst()).toBe(2);
       expect(list.toArray()).toEqual([3]);
     });
 

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

@@ -22,13 +22,13 @@ describe('Deque Tests', () => {
     it('should delete elements from the beginning and end', () => {
       deque.addFirst(1);
       deque.addLast(2);
-      deque.popFirst();
-      deque.popLast();
+      deque.pollFirst();
+      deque.pollLast();
       expect(deque.isEmpty()).toBe(true);
     });
 
     it('should handle edge case when removing from an empty deque', () => {
-      const result = deque.popFirst();
+      const result = deque.pollFirst();
       expect(result).toBeUndefined();
     });
 
@@ -40,18 +40,18 @@ describe('Deque Tests', () => {
 
     it('should handle adding and removing elements alternately', () => {
       deque.addFirst(1);
-      expect(deque.popFirst()).toBe(1);
+      expect(deque.pollFirst()).toBe(1);
       deque.addLast(2);
-      expect(deque.popLast()).toBe(2);
+      expect(deque.pollLast()).toBe(2);
       expect(deque.isEmpty()).toBe(true);
     });
 
     it('should handle adding and removing elements in a cyclic manner', () => {
       deque.addFirst(1);
       deque.addLast(2);
-      expect(deque.popFirst()).toBe(1);
+      expect(deque.pollFirst()).toBe(1);
       deque.addFirst(3);
-      expect(deque.popLast()).toBe(2);
+      expect(deque.pollLast()).toBe(2);
       expect(deque.size).toBe(1);
     });
     // Add more test cases as needed
@@ -75,13 +75,13 @@ describe('Deque Tests', () => {
   //   it('should delete elements from the beginning and end', () => {
   //     objectDeque.addFirst('one');
   //     objectDeque.addLast('two');
-  //     objectDeque.popFirst();
-  //     objectDeque.popLast();
+  //     objectDeque.pollFirst();
+  //     objectDeque.pollLast();
   //     expect(objectDeque.isEmpty()).toBe(true);
   //   });
   //
   //   it('should handle edge case when removing from an empty deque', () => {
-  //     const result = objectDeque.popFirst();
+  //     const result = objectDeque.pollFirst();
   //     expect(result).toBeUndefined();
   //   });
   //
@@ -136,8 +136,8 @@ describe('Deque', () => {
     deque.addFirst(1);
     deque.addLast(2);
 
-    const firstElement = deque.popFirst();
-    const lastElement = deque.popLast();
+    const firstElement = deque.pollFirst();
+    const lastElement = deque.pollLast();
 
     expect(deque.size).toBe(0);
     expect(firstElement).toBe(1);
@@ -166,7 +166,7 @@ describe('Deque', () => {
     deque.addLast(1);
     expect(deque.isEmpty()).toBe(false);
 
-    deque.popFirst();
+    deque.pollFirst();
     expect(deque.isEmpty()).toBe(true);
   });
 });
@@ -200,7 +200,7 @@ describe('Deque', () => {
 //     deque.addLast(1);
 //     deque.addLast(2);
 //
-//     const removedElement = deque.popFirst();
+//     const removedElement = deque.pollFirst();
 //
 //     expect(deque.size).toBe(1);
 //     expect(removedElement).toBe(1);
@@ -211,7 +211,7 @@ describe('Deque', () => {
 //     deque.addLast(1);
 //     deque.addLast(2);
 //
-//     const removedElement = deque.popFirst();
+//     const removedElement = deque.pollFirst();
 //
 //     expect(deque.size).toBe(1);
 //     expect(removedElement).toBe(1);