data-structure-typed 1.50.4 → 1.50.5

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

@@ -21,13 +21,13 @@ if (isCompetitor) {
   });
 }
 
-suite.add(`Native Map ${MILLION.toLocaleString()} set`, () => {
+suite.add(`Native JS Map ${MILLION.toLocaleString()} set`, () => {
   const hm = new Map<number, number>();
 
   for (let i = 0; i < MILLION; i++) hm.set(i, i);
 });
 
-suite.add(`Native Set ${MILLION.toLocaleString()} add`, () => {
+suite.add(`Native JS Set ${MILLION.toLocaleString()} add`, () => {
   const hs = new Set<number>();
 
   for (let i = 0; i < MILLION; i++) hs.add(i);
@@ -49,14 +49,14 @@ if (isCompetitor) {
   });
 }
 
-suite.add(`Native Map ${MILLION.toLocaleString()} set & get`, () => {
+suite.add(`Native JS Map ${MILLION.toLocaleString()} set & get`, () => {
   const hm = new Map<number, number>();
 
   for (let i = 0; i < MILLION; i++) hm.set(i, i);
   for (let i = 0; i < MILLION; i++) hm.get(i);
 });
 
-suite.add(`Native Set ${MILLION.toLocaleString()} add & has`, () => {
+suite.add(`Native JS Set ${MILLION.toLocaleString()} add & has`, () => {
   const hs = new Set<number>();
 
   for (let i = 0; i < MILLION; i++) hs.add(i);
@@ -74,7 +74,7 @@ suite.add(`${MILLION.toLocaleString()} ObjKey set & get`, () => {
   for (let i = 0; i < MILLION; i++) hm.get(objKeys[i]);
 });
 
-suite.add(`Native Map ${MILLION.toLocaleString()} ObjKey set & get`, () => {
+suite.add(`Native JS Map ${MILLION.toLocaleString()} ObjKey set & get`, () => {
   const hm = new Map<[number, number], number>();
   const objs: [number, number][] = [];
   for (let i = 0; i < MILLION; i++) {
@@ -85,7 +85,7 @@ suite.add(`Native Map ${MILLION.toLocaleString()} ObjKey set & get`, () => {
   for (let i = 0; i < MILLION; i++) hm.get(objs[i]);
 });
 
-suite.add(`Native Set ${MILLION.toLocaleString()} ObjKey add & has`, () => {
+suite.add(`Native JS 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/heap/heap.test.ts

@@ -1,26 +1,26 @@
-import { FibonacciHeap, Heap } from '../../../../src';
+import { Heap } from '../../../../src';
 import * as Benchmark from 'benchmark';
-import { magnitude } from '../../../utils';
+import { getRandomInt, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const { HUNDRED_THOUSAND, TEN_THOUSAND } = magnitude;
+const { HUNDRED_THOUSAND } = magnitude;
+const indicesHT = new Array(HUNDRED_THOUSAND).fill(0).map(() => getRandomInt(0, HUNDRED_THOUSAND - 1));
 
 suite
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
+    const heap = new Heap<number>([], { comparator: (a, b) => b - a });
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(indicesHT[i]);
+  })
   .add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
     const heap = new Heap<number>([], { comparator: (a, b) => b - a });
 
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(indicesHT[i]);
     for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.poll();
-  })
-  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & dfs`, () => {
-    const heap = new Heap<number>([], { comparator: (a, b) => b - a });
-    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(i);
-    heap.dfs();
-  })
-  .add(`${TEN_THOUSAND.toLocaleString()} fib add & pop`, () => {
-    const fbHeap = new FibonacciHeap<number>();
-    for (let i = 1; i <= TEN_THOUSAND; i++) fbHeap.push(i);
-    for (let i = 1; i <= TEN_THOUSAND; i++) fbHeap.pop();
   });
+// .add(`${TEN_THOUSAND.toLocaleString()} fib add & pop`, () => {
+//   const fbHeap = new FibonacciHeap<number>();
+//   for (let i = 1; i <= TEN_THOUSAND; i++) fbHeap.push(i);
+//   for (let i = 1; i <= TEN_THOUSAND; i++) fbHeap.pop();
+// });
 
 export { suite };

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

@@ -1,5 +1,5 @@
-import { PriorityQueue as CPriorityQueue } from 'js-sdsl';
 import { PriorityQueue } from '../../../../src';
+import { PriorityQueue as CPriorityQueue } from 'js-sdsl';
 import * as Benchmark from 'benchmark';
 import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
@@ -7,12 +7,17 @@ import { isCompetitor } from '../../../config';
 const suite = new Benchmark.Suite();
 const { HUNDRED_THOUSAND } = magnitude;
 
-suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
-  const pq = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
+suite
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add`, () => {
+    const heap = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(i);
+  })
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & poll`, () => {
+    const heap = new PriorityQueue<number>([], { comparator: (a, b) => b - a });
 
-  for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.add(i);
-  for (let i = 0; i < HUNDRED_THOUSAND; i++) pq.poll();
-});
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.add(i);
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) heap.poll();
+  });
 if (isCompetitor) {
   suite.add(`CPT ${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
     const pq = new CPriorityQueue<number>();

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

@@ -21,25 +21,25 @@ if (isCompetitor) {
 }
 
 suite
-  // .add(`${TEN_THOUSAND.toLocaleString()} push & delete`, () => {
-  //   const deque = new Deque<number>();
-  //
-  //   for (let i = 0; i < TEN_THOUSAND; i++) deque.push(i);
-  //   for (let i = 0; i < TEN_THOUSAND; i++) deque.delete(randomIndicesTenThousand[i]);
-  // })
   .add(`${MILLION.toLocaleString()} push & pop`, () => {
     const deque = new Deque<number>();
 
     for (let i = 0; i < MILLION; i++) deque.push(i);
     for (let i = 0; i < MILLION; i++) deque.pop();
   })
+  .add(`${MILLION.toLocaleString()} push & shift`, () => {
+    const deque = new Deque<number>();
+
+    for (let i = 0; i < MILLION; i++) deque.push(i);
+    for (let i = 0; i < MILLION; 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`, () => {
+  .add(`Native JS Array ${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
     const array = new Array<number>();
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) array.push(i);
@@ -51,7 +51,7 @@ suite
     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`, () => {
+  .add(`Native JS Array ${HUNDRED_THOUSAND.toLocaleString()} unshift & shift`, () => {
     const array = new Array<number>();
 
     for (let i = 0; i < HUNDRED_THOUSAND; i++) array.unshift(i);

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

@@ -25,18 +25,11 @@ suite.add(`${HUNDRED_THOUSAND.toLocaleString()} push & shift`, () => {
   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>();
+suite.add(`Native JS 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();
-  });
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.push(i);
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) arr.shift();
+});
 
 export { suite };

package/test/performance/reportor.ts

@@ -4,6 +4,7 @@ import * as fs from 'fs';
 import * as fastGlob from 'fast-glob';
 import { Color, numberFix, render } from '../utils';
 import { PerformanceTest } from './types';
+import * as console from 'console';
 
 const args = process.argv.slice(2);
 
@@ -171,7 +172,48 @@ function replaceMarkdownContent(startMarker: string, endMarker: string, newText:
   });
 }
 
-performanceTests.forEach(item => {
+const order = [
+  'heap',
+  'rb-tree',
+  'queue',
+  'deque',
+  'hash-map',
+  'trie',
+  'avl-tree',
+  'binary-tree-overall',
+  'directed-graph',
+  'doubly-linked-list',
+  'singly-linked-list',
+  'priority-queue',
+  'stack'
+];
+
+const sortedPerformanceTests = [...performanceTests].sort((a, b) => {
+  const indexA = order.indexOf(a.testName);
+  const indexB = order.indexOf(b.testName);
+
+  // If both a and b are in the order, sort them according to their indices in the order.
+  if (indexA !== -1 && indexB !== -1) {
+    return indexA - indexB;
+  }
+
+  // If there is only 'a' in the order, then place 'b' in front.
+  if (indexA !== -1) {
+    return 1;
+  }
+
+  // If only b is in the order, then a should be placed before it.
+  if (indexB !== -1) {
+    return -1;
+  }
+
+  // If neither a nor b are in order, keep their original order
+  return 0;
+});
+
+console.log(`${GREEN} Found tests${END}: ${sortedPerformanceTests.map(test => test.testName)}`);
+
+sortedPerformanceTests.forEach(item => {
   const { suite, testName, file } = item;
 
   console.log(coloredLabeled('Running', file));

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

@@ -39,12 +39,12 @@ describe('DoublyLinkedList Operation Test', () => {
 
   it('should clone', function () {
     const dList = new DoublyLinkedList<string>();
-    dList.addLast('1');
-    dList.addLast('6');
-    dList.addLast('2');
-    dList.addLast('0');
-    dList.addLast('5');
-    dList.addLast('9');
+    dList.push('1');
+    dList.push('6');
+    dList.push('2');
+    dList.push('0');
+    dList.push('5');
+    dList.push('9');
     dList.delete('2');
     expect([...dList]).toEqual(['1', '6', '0', '5', '9']);
     const cloned = dList.clone();

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.pollLast()).toBe(2);
+      expect(list.pop()).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.pollFirst()).toBe(2);
+      expect(list.shift()).toBe(2);
       expect(list.toArray()).toEqual([3]);
     });
 
@@ -62,7 +62,7 @@ describe('SinglyLinkedList Operation Test', () => {
   describe('unshift', () => {
     it('should add elements to the beginning of the list', () => {
       list.unshift(1);
-      list.addFirst(2);
+      list.unshift(2);
       expect(list.toArray()).toEqual([2, 1]);
     });
   });
@@ -350,12 +350,12 @@ describe('SinglyLinkedList Operation Test', () => {
 
   it('should clone', function () {
     const sList = new SinglyLinkedList<string>();
-    sList.addLast('1');
-    sList.addLast('6');
-    sList.addLast('2');
-    sList.addLast('0');
-    sList.addLast('5');
-    sList.addLast('9');
+    sList.push('1');
+    sList.push('6');
+    sList.push('2');
+    sList.push('0');
+    sList.push('5');
+    sList.push('9');
     sList.delete('2');
     expect([...sList]).toEqual(['1', '6', '0', '5', '9']);
     const cloned = sList.clone();
@@ -478,7 +478,7 @@ describe('SinglyLinkedList', () => {
   });
 
   it('should map the list', () => {
-    list.addLast(1);
+    list.push(1);
     list.push(2);
     list.push(3);
     expect(list.map(value => value * 2).toArray()).toEqual([2, 4, 6]);

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

@@ -65,21 +65,21 @@ describe('SkipList Test2', () => {
     skipList.add(4, 'Four');
   });
 
-  it('getFirst() should return the getFirst element', () => {
+  it('first() should return the first element', () => {
     expect(skipList.first).toBe('One');
   });
 
-  it('getLast() should return the getLast element', () => {
+  it('last() should return the last element', () => {
     expect(skipList.last).toBe('Four');
   });
 
-  it('higher(key) should return the getFirst element greater than the given key', () => {
+  it('higher(key) should return the first element greater than the given key', () => {
     expect(skipList.higher(2)).toBe('Three');
     expect(skipList.higher(3)).toBe('Four');
     expect(skipList.higher(4)).toBeUndefined();
   });
 
-  it('lower(key) should return the getLast element less than the given key', () => {
+  it('lower(key) should return the last element less than the given key', () => {
     expect(skipList.lower(2)).toBe('One');
     expect(skipList.lower(1)).toBe(undefined);
   });

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

@@ -52,12 +52,12 @@ describe('Deque - Basic Operations', () => {
 
   it('should clone', function () {
     const deque = new Deque<string>();
-    deque.addLast('1');
-    deque.addLast('6');
-    deque.addLast('2');
-    deque.addLast('0');
-    deque.addLast('5');
-    deque.addLast('9');
+    deque.push('1');
+    deque.push('6');
+    deque.push('2');
+    deque.push('0');
+    deque.push('5');
+    deque.push('9');
     expect(deque.size).toBe(6);
     deque.delete('2');
     expect(deque.size).toBe(5);
@@ -70,7 +70,7 @@ describe('Deque - Basic Operations', () => {
     expect([...deque]).toEqual(['1', '6', '0', '9']);
     expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
     expect(cloned.size).toBe(5);
-    cloned.addLast('8');
+    cloned.push('8');
     expect(cloned.size).toBe(6);
     cloned.delete('6');
     expect(cloned.size).toBe(5);
@@ -239,52 +239,52 @@ describe('Deque - Additional Operations', () => {
     deque = new Deque<number>();
   });
 
-  test('addLast should add an element to the end', () => {
-    deque.addLast(1);
-    deque.addLast(2);
+  test('push should add an element to the end', () => {
+    deque.push(1);
+    deque.push(2);
     expect(deque.last).toBe(2);
     expect(deque.size).toBe(2);
   });
 
-  test('pollLast should remove and return the last element', () => {
-    deque.addLast(1);
-    deque.addLast(2);
-    expect(deque.pollLast()).toBe(2);
+  test('pop should remove and return the last element', () => {
+    deque.push(1);
+    deque.push(2);
+    expect(deque.pop()).toBe(2);
     expect(deque.size).toBe(1);
   });
 
-  test('addFirst should add an element to the beginning', () => {
-    deque.addFirst(1);
-    deque.addFirst(2);
+  test('unshift should add an element to the beginning', () => {
+    deque.unshift(1);
+    deque.unshift(2);
     expect(deque.first).toBe(2);
     expect(deque.size).toBe(2);
   });
 
-  test('pollFirst should remove and return the first element', () => {
-    deque.addFirst(1);
-    deque.addFirst(2);
-    expect(deque.pollFirst()).toBe(2);
+  test('shift should remove and return the first element', () => {
+    deque.unshift(1);
+    deque.unshift(2);
+    expect(deque.shift()).toBe(2);
     expect(deque.size).toBe(1);
   });
 
   test('clear should reset the deque', () => {
-    deque.addFirst(1);
+    deque.unshift(1);
     deque.clear();
     expect(deque.size).toBe(0);
     expect(deque.isEmpty()).toBeTruthy();
   });
 
   test('begin should yield elements from the beginning', () => {
-    deque.addLast(1);
-    deque.addLast(2);
+    deque.push(1);
+    deque.push(2);
     const iterator = deque.begin();
     expect(iterator.next().value).toBe(1);
     expect(iterator.next().value).toBe(2);
   });
 
   test('reverseBegin should yield elements in reverse order', () => {
-    deque.addLast(1);
-    deque.addLast(2);
+    deque.push(1);
+    deque.push(2);
     const iterator = deque.reverseBegin();
     expect(iterator.next().value).toBe(2);
     expect(iterator.next().value).toBe(1);

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

@@ -23,24 +23,24 @@ describe('Queue', () => {
 
   test('shift should remove the first element', () => {
     queue.push(1);
-    queue.enqueue(2);
+    queue.push(2);
     expect(queue.shift()).toBe(1);
     expect(queue.size).toBe(1);
   });
 
   test('shift should return undefined if queue is empty', () => {
-    expect(queue.dequeue()).toBeUndefined();
+    expect(queue.shift()).toBeUndefined();
   });
 
-  test('peek should return the first element without removing it', () => {
+  test('first should return the first element without removing it', () => {
     queue.push(1);
     queue.push(2);
-    expect(queue.peek()).toBe(1);
+    expect(queue.first).toBe(1);
     expect(queue.size).toBe(2);
   });
 
-  test('peek should return undefined if queue is empty', () => {
-    expect(queue.peek()).toBeUndefined();
+  test('first should return undefined if queue is empty', () => {
+    expect(queue.first).toBeUndefined();
   });
 
   test('size should return the number of elements', () => {
@@ -167,12 +167,12 @@ describe('Queue - Additional Methods', () => {
   test('peekLast should return the last element without removing it', () => {
     queue.push(1);
     queue.push(2);
-    expect(queue.peekLast()).toBe(2);
+    expect(queue.last).toBe(2);
     expect(queue.size).toBe(2);
   });
 
   test('peekLast should return undefined if queue is empty', () => {
-    expect(queue.peekLast()).toBeUndefined();
+    expect(queue.last).toBeUndefined();
   });
 
   test('at should return the element at the specified index', () => {
@@ -239,25 +239,25 @@ describe('LinkedListQueue', () => {
     queue = new LinkedListQueue<string>();
   });
 
-  it('should enqueue elements to the end of the queue', () => {
-    queue.enqueue('A');
-    queue.enqueue('B');
-    expect(queue.peek()).toBe('A');
+  it('should push elements to the end of the queue', () => {
+    queue.push('A');
+    queue.push('B');
+    expect(queue.first).toBe('A');
     expect(queue.size).toBe(2);
   });
 
-  it('should dequeue elements from the front of the queue', () => {
-    queue.enqueue('A');
-    queue.enqueue('B');
-    const dequeued = queue.dequeue();
+  it('should shift elements from the front of the queue', () => {
+    queue.push('A');
+    queue.push('B');
+    const dequeued = queue.shift();
     expect(dequeued).toBe('A');
-    expect(queue.peek()).toBe('B');
+    expect(queue.first).toBe('B');
     expect(queue.size).toBe(1);
   });
 
   it('should peek at the front of the queue', () => {
-    queue.enqueue('A');
-    queue.enqueue('B');
-    expect(queue.peek()).toBe('A');
+    queue.push('A');
+    queue.push('B');
+    expect(queue.first).toBe('A');
   });
 });