data-structure-typed 1.45.3 → 1.46.0

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

@@ -1,14 +1,3 @@
-export const enum IterateDirection {
-  DEFAULT = 0,
-  REVERSE = 1
-}
-
-export type HashMapOptions<T> = {
-  sizeFunction?: number | (() => number);
-  fixedLength?: number;
-  forEach: (callback: (el: T) => void) => void;
-};
-
 export type HashMapLinkedNode<K, V> = {
   key: K;
   value: V;

package/src/types/helpers.ts

@@ -9,3 +9,18 @@ export enum CP {
   eq = 'eq',
   gt = 'gt'
 }
+
+export const enum IterateDirection {
+  DEFAULT = 0,
+  REVERSE = 1
+}
+
+export interface IterableWithSize<T> extends Iterable<T> {
+  size: number;
+}
+
+export interface IterableWithLength<T> extends Iterable<T> {
+  length: number;
+}
+
+export type IterableWithSizeOrLength<T> = IterableWithSize<T> | IterableWithLength<T>

package/src/utils/utils.ts

@@ -97,3 +97,5 @@ export const isObjOrFunc = (input: unknown): input is Record<string, unknown> |
   const inputType = typeof input;
   return (inputType === 'object' && input !== null) || inputType === 'function';
 };
+
+export const calcMinUnitsRequired = (totalQuantity: number, unitSize: number) => Math.floor((totalQuantity + unitSize - 1) / unitSize)

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

@@ -7,6 +7,25 @@ import { isCompetitor } from '../../../config';
 const suite = new Benchmark.Suite();
 const { LINEAR } = magnitude;
 
+suite.add(`${LINEAR.toLocaleString()} push`, () => {
+  const list = new DoublyLinkedList<number>();
+
+  for (let i = 0; i < LINEAR; i++) {
+    list.push(i);
+  }
+});
+
+
+if (isCompetitor) {
+  suite.add(`${LINEAR.toLocaleString()} CPT push`, () => {
+    const list = new CLinkedList<number>();
+
+    for (let i = 0; i < LINEAR; i++) {
+      list.pushBack(i);
+    }
+  });
+}
+
 suite.add(`${LINEAR.toLocaleString()} unshift`, () => {
   const list = new DoublyLinkedList<number>();
 
@@ -14,6 +33,7 @@ suite.add(`${LINEAR.toLocaleString()} unshift`, () => {
     list.unshift(i);
   }
 });
+
 if (isCompetitor) {
   suite.add(`${LINEAR.toLocaleString()} CPT unshift`, () => {
     const list = new CLinkedList<number>();
@@ -23,6 +43,7 @@ if (isCompetitor) {
     }
   });
 }
+
 suite
   .add(`${LINEAR.toLocaleString()} unshift & shift`, () => {
     const list = new DoublyLinkedList<number>();

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

@@ -5,28 +5,28 @@ import { magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 const suite = new Benchmark.Suite();
-const { TEN_THOUSAND } = magnitude;
+const { HUNDRED_THOUSAND } = magnitude;
 
-suite.add(`${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
+suite.add(`${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
   const pq = new PriorityQueue<number>({ comparator: (a, b) => b - a });
 
-  for (let i = 0; i < TEN_THOUSAND; i++) {
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
     pq.add(i);
   }
 
-  for (let i = 0; i < TEN_THOUSAND; i++) {
+  for (let i = 0; i < HUNDRED_THOUSAND; i++) {
     pq.pop();
   }
 });
 if (isCompetitor) {
-  suite.add(`${TEN_THOUSAND.toLocaleString()} CPT add & pop`, () => {
+  suite.add(`${HUNDRED_THOUSAND.toLocaleString()} CPT add & pop`, () => {
     const pq = new CPriorityQueue<number>();
 
-    for (let i = 0; i < TEN_THOUSAND; i++) {
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
       pq.push(i);
     }
 
-    for (let i = 0; i < TEN_THOUSAND; i++) {
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
       pq.pop();
     }
   });

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

@@ -9,22 +9,33 @@ const { LINEAR } = magnitude;
 
 suite.add(`${LINEAR.toLocaleString()} push`, () => {
   const deque = new Deque<number>();
-  for (let i = 0; i < LINEAR; i++) {
-    deque.push(i);
-  }
+  for (let i = 0; i < LINEAR; i++) deque.push(i);
 });
+
 if (isCompetitor) {
   suite.add(`${LINEAR.toLocaleString()} CPT push`, () => {
-    const deque = new CDeque<number>();
-    for (let i = 0; i < LINEAR; i++) {
-      deque.pushBack(i);
-    }
+    const _deque = new CDeque<number>();
+    for (let i = 0; i < LINEAR; i++) _deque.pushBack(i);
   });
 }
-suite.add(`${LINEAR.toLocaleString()} shift`, () => {
-  const deque = new Deque<number>();
-  for (let i = 0; i < LINEAR; i++) {
-    deque.push(i);
-    deque.shift();
-  }
+
+
+suite.add(`${LINEAR.toLocaleString()} push & pop`, () => {
+  const _deque = new Deque<number>();
+
+  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();
 });

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

@@ -171,10 +171,10 @@ describe('HashMap', () => {
     let index = 0;
     stdMap.forEach((value, key) => {
       if (index === 0) {
-        expect(hashMap.front).toEqual([key, value]);
+        expect(hashMap.first).toEqual([key, value]);
         expect(hashMap.begin.current[0]).toEqual(key);
       } else if (index === hashMap.size - 1) {
-        expect(hashMap.back).toEqual([key, value]);
+        expect(hashMap.last).toEqual([key, value]);
         expect(hashMap.reverseBegin.current[0]).toEqual(key);
       } else if (index <= 1000) {
         expect(hashMap.getAt(index)).toEqual([key, value]);
@@ -217,11 +217,11 @@ describe('HashMap', () => {
   test('should return the last element', () => {
     hashMap.set('key1', 'value1');
     hashMap.set('key2', 'value2');
-    expect(hashMap.back).toEqual(['key2', 'value2']);
+    expect(hashMap.last).toEqual(['key2', 'value2']);
   });
 
   test('should return undefined for empty map', () => {
-    expect(hashMap.back).toBeUndefined();
+    expect(hashMap.last).toBeUndefined();
   });
 
   test('should get element at specific index', () => {

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

@@ -1,6 +1,7 @@
 import { FibonacciHeap, MaxHeap, MinHeap } from '../../../../src';
 import { logBigOMetricsWrap } from '../../../utils';
 
+
 describe('Heap Operation Test', () => {
   it('should numeric heap work well', function () {
     const minNumHeap = new MinHeap<number>();
@@ -262,7 +263,7 @@ describe('FibonacciHeap Stress Test', () => {
 //   const minHeap = new MinHeap<number>();
 //   const cHeap = new CHeap<number>();
 //   const cPQ = new PriorityQueue<number>(undefined, (a, b) => a - b);
-//   const n = 10000;
+//   const n = 100000;
 //
 //   it('should add performance well', () => {
 //     const heapCost = calcRunTime(() => {

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

@@ -52,7 +52,7 @@ describe('MaxPriorityQueue Operation Test', () => {
 
   it('should correctly heapify an array', () => {
     const array = [5, 3, 7, 1];
-    const heap = MaxPriorityQueue.heapify<number>({ nodes: array, comparator: (a, b) => b - a });
+    const heap = MaxPriorityQueue.heapify<number>({ elements: array, comparator: (a, b) => b - a });
     heap.refill(array);
 
     expect(heap.poll()).toBe(7);
@@ -62,8 +62,8 @@ describe('MaxPriorityQueue Operation Test', () => {
   });
 
   it('should correctly heapify an object array', () => {
-    const nodes = [{ keyA: 5 }, { keyA: 3 }, { keyA: 7 }, { keyA: 1 }];
-    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>({ nodes: nodes, comparator: (a, b) => b.keyA - a.keyA });
+    const elements = [{ keyA: 5 }, { keyA: 3 }, { keyA: 7 }, { keyA: 1 }];
+    const maxPQ = MaxPriorityQueue.heapify<{ keyA: number }>({ elements, comparator: (a, b) => b.keyA - a.keyA });
 
     expect(maxPQ.poll()?.keyA).toBe(7);
     expect(maxPQ.poll()?.keyA).toBe(5);

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

@@ -15,7 +15,7 @@ describe('PriorityQueue Operation Test', () => {
     expect(minPQ.peek()).toBe(4);
     expect(
       PriorityQueue.heapify({
-        nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10],
+        elements: [3, 2, 1, 5, 6, 7, 8, 9, 10],
         comparator: (a, b) => a - b
       }).toArray()
     ).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
@@ -32,7 +32,7 @@ describe('PriorityQueue Operation Test', () => {
     expect(maxPriorityQueue.peek()).toBe(3);
     expect(
       PriorityQueue.heapify({
-        nodes: [3, 2, 1, 5, 6, 7, 8, 9, 10],
+        elements: [3, 2, 1, 5, 6, 7, 8, 9, 10],
         comparator: (a, b) => a - b
       }).toArray()
     ).toEqual([1, 2, 3, 5, 6, 7, 8, 9, 10]);
@@ -42,7 +42,7 @@ describe('PriorityQueue Operation Test', () => {
     const minPQ1 = new PriorityQueue<number>({ comparator: (a, b) => a - b });
     minPQ1.refill([2, 5, 8, 3, 1, 6, 7, 4]);
     const clonedPriorityQueue = minPQ1.clone();
-    expect(clonedPriorityQueue.getNodes()).toEqual(minPQ1.getNodes());
+    expect(clonedPriorityQueue.elements).toEqual(minPQ1.elements);
     expect(clonedPriorityQueue.sort()).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
     expect(minPQ1.dfs('in')).toEqual([4, 3, 2, 5, 1, 8, 6, 7]);
     expect(minPQ1.dfs('post')).toEqual([4, 3, 5, 2, 8, 7, 6, 1]);