data-structure-typed 1.52.4 → 1.52.6

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

@@ -13,7 +13,7 @@ describe('HashMap', () => {
     expect(hashMap.isEmpty()).toBe(true);
   });
 
-  it('should put and get values', () => {
+  it('should set and get values', () => {
     hashMap.set('one', 1);
     hashMap.set('two', 2);
     hashMap.set('three', 3);
@@ -122,15 +122,18 @@ describe('HashMap', () => {
     it('should add a key-value pair', () => {
       hashMap.set('key1', 'value1');
       expect(hashMap.get('key1')).toBe('value1');
+      expect(hashMap.hasValue('value1')).toBe(true);
+      expect(hashMap.hasValue('value2')).toBe(false);
     });
 
     it('should handle object keys correctly', () => {
       const keyObj = { id: 1 };
       hashMap.set(keyObj, 'objectValue');
+      expect(hashMap.has(keyObj)).toBe(true);
       expect(hashMap.get(keyObj)).toBe('objectValue');
     });
 
-    test('Inheritability test', () => {
+    it('Inheritability test', () => {
       class ExtendedHashMap<K, V> extends HashMap<K, V> {
         someOtherParam?: string;
 
@@ -154,7 +157,7 @@ describe('HashMap', () => {
       expect(eHM.get('one')).toBe(1);
     });
 
-    test('should raw elements toEntry', () => {
+    it('should raw elements toEntry', () => {
       const rawCollection = [
         { id: 1, name: 'item 1' },
         { id: 2, name: 'item 2' }
@@ -238,17 +241,19 @@ describe('HashMap', () => {
   describe('HashMap for coordinate object keys', () => {
     const hashMap: HashMap<[number, number], number> = new HashMap();
     const codObjs: [number, number][] = [];
-
-    test('set elements in hash map', () => {
-      for (let i = 0; i < 1000; i++) {
-        const codObj: [number, number] = [getRandomInt(-10000, 10000), i];
-        codObjs.push(codObj);
+    for (let i = 0; i < 10; i++) {
+      const codObj: [number, number] = [getRandomInt(-10000, 10000), i];
+      codObjs.push(codObj);
+    }
+    it('set elements in hash map', () => {
+      for (let i = 0; i < codObjs.length; i++) {
+        const codObj = codObjs[i];
         hashMap.set(codObj, i);
       }
     });
 
-    test('get elements in hash map', () => {
-      for (let i = 0; i < 1000; i++) {
+    it('get elements in hash map', () => {
+      for (let i = 0; i < codObjs.length; i++) {
         const codObj = codObjs[i];
         if (codObj) {
           expect(hashMap.get(codObj)).toBe(i);
@@ -256,8 +261,12 @@ describe('HashMap', () => {
       }
     });
 
-    test('delete elements in hash map', () => {
-      for (let i = 0; i < 1000; i++) {
+    it('should spread elements in hash map', () => {
+      expect([...hashMap]).toEqual(codObjs.map(codObj => [codObj, codObj[1]]));
+    });
+
+    it('delete elements in hash map', () => {
+      for (let i = 0; i < 10; i++) {
         if (i === 500) expect(hashMap.size).toBe(500);
         const codObj = codObjs[i];
         if (codObj) hashMap.delete(codObj);
@@ -285,17 +294,27 @@ describe('HashMap', () => {
       ]);
     });
 
-    test('keys', () => {
+    it('keys', () => {
       expect([...hm.keys()]).toEqual([2, 3, 4, 5, 6]);
     });
 
-    test('values', () => {
+    it('values', () => {
       expect([...hm.values()]).toEqual([2, 3, 4, 5, 6]);
     });
+
+    it('print', () => {
+      expect(hm.print()).toEqual([
+        [2, 2],
+        [3, 3],
+        [4, 4],
+        [5, 5],
+        [6, 6]
+      ]);
+    });
   });
 
   describe('HashMap HOF', () => {
-    let hashMap: HashMap;
+    let hashMap: HashMap<string, string>;
 
     beforeEach(() => {
       hashMap = new HashMap<string, string>();
@@ -304,34 +323,91 @@ describe('HashMap', () => {
       hashMap.set('key3', 'value3');
     });
 
-    test('every() returns true if all elements match the condition', () => {
+    it('every() returns true if all elements match the condition', () => {
       expect(hashMap.every(value => typeof value === 'string')).toBe(true);
     });
 
-    test('some() returns true if any element matches the condition', () => {
+    it('some() returns true if any element matches the condition', () => {
       expect(hashMap.some((value, key) => key === 'key1')).toBe(true);
     });
 
-    test('forEach() should execute a function for each element', () => {
+    it('forEach() should execute a function for each element', () => {
       const mockCallback = jest.fn();
       hashMap.forEach(mockCallback);
       expect(mockCallback.mock.calls.length).toBe(3);
     });
 
-    test('map() should transform each element', () => {
+    it('map() should transform each element', () => {
       const newHashMap = hashMap.map(value => value.toUpperCase());
       expect(newHashMap.get('key1')).toBe('VALUE1');
     });
 
-    test('filter() should remove elements that do not match the condition', () => {
+    it('filter() should remove elements that do not match the condition', () => {
       const filteredHashMap = hashMap.filter((value, key) => key !== 'key1');
       expect(filteredHashMap.has('key1')).toBe(false);
     });
 
-    test('reduce() should accumulate values', () => {
+    it('reduce() should accumulate values', () => {
       const result = hashMap.reduce((acc, value) => acc + value, '');
       expect(result).toBe('value1value2value3');
     });
+
+    it('should spread in an array', () => {
+      expect([...hashMap]).toEqual([
+        ['key1', 'value1'],
+        ['key2', 'value2'],
+        ['key3', 'value3']
+      ]);
+    });
+
+    it('should find', () => {
+      const found = hashMap.find(value => value === 'value1');
+      expect(found).toEqual(['key1', 'value1']);
+      const notFound = hashMap.find(value => value === 'value6');
+      expect(notFound).toEqual(undefined);
+    });
+
+    it('should every', () => {
+      const isEvery = hashMap.every(value => value.substring(0, 5) === 'value');
+      expect(isEvery).toEqual(true);
+      const isEvery4 = hashMap.every(value => value.substring(0, 4) === 'value');
+      expect(isEvery4).toEqual(false);
+    });
+
+    it('should some', () => {
+      const isSome = hashMap.some(value => value.substring(5, 6) === '2');
+      expect(isSome).toEqual(true);
+      const isSome4 = hashMap.some(value => value.substring(0, 5) === 'value');
+      expect(isSome4).toEqual(true);
+    });
+
+    it('should forEach', () => {
+      hashMap.forEach((value, key, index) => expect(value.substring(5, 6)).toBe(String(index + 1)));
+    });
+
+    it('should entries', () => {
+      const entries = hashMap.entries();
+      expect(entries.next()).toEqual({ done: false, value: ['key1', 'value1'] });
+      expect(entries.next()).toEqual({ done: false, value: ['key2', 'value2'] });
+      expect(entries.next()).toEqual({ done: false, value: ['key3', 'value3'] });
+      expect(entries.next()).toEqual({ done: true, value: undefined });
+    });
+
+    it('should keys', () => {
+      const keys = hashMap.keys();
+      expect(keys.next()).toEqual({ done: false, value: 'key1' });
+      expect(keys.next()).toEqual({ done: false, value: 'key2' });
+      expect(keys.next()).toEqual({ done: false, value: 'key3' });
+      expect(keys.next()).toEqual({ done: true, value: undefined });
+    });
+
+    it('should values', () => {
+      const values = hashMap.values();
+      expect(values.next()).toEqual({ done: false, value: 'value1' });
+      expect(values.next()).toEqual({ done: false, value: 'value2' });
+      expect(values.next()).toEqual({ done: false, value: 'value3' });
+      expect(values.next()).toEqual({ done: true, value: undefined });
+    });
   });
 });
 
@@ -347,6 +423,7 @@ describe('LinkedHashMap', () => {
   });
 
   it('should add a key-value pair', () => {
+    expect(hashMap.first).toBe(undefined);
     hashMap.set('key1', 'value1');
     expect(hashMap.get('key1')).toBe('value1');
   });
@@ -441,29 +518,99 @@ describe('LinkedHashMap', () => {
     compareHashMaps(hashMap, stdMap);
   });
 
-  test('should iterate correctly with reverse iterators', () => {
+  it('should iterate correctly with reverse iterators', () => {
     hashMap.set('key1', 'value1');
     hashMap.set('key2', 'value2');
     const iterator = hashMap.reverseBegin();
     expect(iterator.next().value).toEqual(['key2', 'value2']);
   });
 
-  test('should return the last element', () => {
+  it('should return the last element', () => {
     hashMap.set('key1', 'value1');
     hashMap.set('key2', 'value2');
     expect(hashMap.last).toEqual(['key2', 'value2']);
   });
 
-  test('should return undefined for empty map', () => {
+  it('should return undefined for empty map', () => {
     expect(hashMap.last).toBeUndefined();
   });
 
-  test('should get element at specific index', () => {
+  it('should get element at specific index', () => {
     hashMap.set('key1', 'value1');
     hashMap.set('key2', 'value2');
     expect(hashMap.at(1)).toBe('value2');
   });
 
+  it('should hashFn, objHashFn, toEntryFn work well', () => {
+    const data: Array<{ name: number }> = [{ name: 1 }, { name: 2 }, { name: 3 }];
+    const hm = new LinkedHashMap(data, {
+      hashFn: key => String(key),
+      objHashFn: obj => obj,
+      toEntryFn: ({ name }) => [{ name }, name]
+    });
+
+    expect(hm.hashFn).toBeTruthy();
+    expect(hm.objHashFn).toBeTruthy();
+    expect(hm.toEntryFn).toBeTruthy();
+    expect([...hm]).toEqual([
+      [{ name: 1 }, 1],
+      [{ name: 2 }, 2],
+      [{ name: 3 }, 3]
+    ]);
+  });
+
+  it('should begin, reverseBegin', () => {
+    const data: Array<{ name: number }> = [{ name: 1 }, { name: 2 }, { name: 3 }];
+    const hm = new LinkedHashMap(data, {
+      hashFn: key => String(key),
+      objHashFn: obj => obj,
+      toEntryFn: ({ name }) => [{ name }, name]
+    });
+
+    expect(hm.begin().next()).toEqual({
+      done: false,
+      value: [
+        {
+          name: 1
+        },
+        1
+      ]
+    });
+
+    expect(hm.reverseBegin().next()).toEqual({
+      done: false,
+      value: [
+        {
+          name: 3
+        },
+        3
+      ]
+    });
+  });
+
+  it('should clone', () => {
+    hashMap = new LinkedHashMap<string, number>();
+
+    hashMap.set('one', 1);
+    hashMap.set('two', 2);
+    for (let i = 3; i <= 100; i++) {
+      hashMap.set(i.toString(), i);
+    }
+
+    expect(hashMap.get('one')).toBe(1);
+    expect(hashMap.get('two')).toBe(2);
+    expect(hashMap.get('86')).toBe(86);
+    expect(hashMap.size).toBe(100);
+    hashMap.delete('two');
+    expect(hashMap.size).toBe(99);
+
+    const cloned = hashMap.clone();
+    expect(cloned.get('one')).toBe(1);
+    expect(cloned.get('two')).toBe(undefined);
+    expect(cloned.get('86')).toBe(86);
+    expect(cloned.size).toBe(99);
+  });
+
   describe('LinkedHashMap basic', () => {
     let hashMap: LinkedHashMap<string, number>;
 
@@ -506,6 +653,9 @@ describe('LinkedHashMap', () => {
       hashMap.delete('one');
       expect(hashMap.get('one')).toBeUndefined();
       expect(hashMap.size).toBe(1);
+      hashMap.deleteAt(0);
+      // expect(hashMap.get('two')).toBe(undefined); // TODO #99
+      expect(hashMap.size).toBe(0);
     });
 
     it('should clear the LinkedHashMap', () => {
@@ -570,7 +720,7 @@ describe('LinkedHashMap', () => {
     const hashMap: LinkedHashMap<[number, number], number> = new LinkedHashMap();
     const codObjs: [number, number][] = [];
 
-    test('set elements in hash map', () => {
+    it('set elements in hash map', () => {
       for (let i = 0; i < 1000; i++) {
         const codObj: [number, number] = [getRandomInt(-10000, 10000), i];
         codObjs.push(codObj);
@@ -578,7 +728,7 @@ describe('LinkedHashMap', () => {
       }
     });
 
-    test('get elements in hash map', () => {
+    it('get elements in hash map', () => {
       for (let i = 0; i < 1000; i++) {
         const codObj = codObjs[i];
         if (codObj) {
@@ -587,7 +737,7 @@ describe('LinkedHashMap', () => {
       }
     });
 
-    test('delete elements in hash map', () => {
+    it('delete elements in hash map', () => {
       for (let i = 0; i < 1000; i++) {
         if (i === 500) expect(hashMap.size).toBe(500);
         const codObj = codObjs[i];
@@ -616,15 +766,15 @@ describe('LinkedHashMap', () => {
       ]);
     });
 
-    test('keys', () => {
+    it('keys', () => {
       expect([...hm.keys()]).toEqual([2, 3, 4, 5, 6]);
     });
 
-    test('values', () => {
+    it('values', () => {
       expect([...hm.values()]).toEqual([2, 3, 4, 5, 6]);
     });
 
-    test('entries', () => {
+    it('entries', () => {
       expect([...hm.entries()]).toEqual([
         [2, 2],
         [3, 3],
@@ -634,21 +784,61 @@ describe('LinkedHashMap', () => {
       ]);
     });
 
-    test('every', () => {
+    it('every', () => {
       expect(hm.every(value => value > 4)).toBe(false);
     });
 
-    test('some', () => {
+    it('some', () => {
       expect(hm.some(value => value > 6)).toBe(false);
     });
 
-    test('hasValue', () => {
+    it('hasValue', () => {
       expect(hm.hasValue(3)).toBe(true);
       expect(hm.hasValue(7)).toBe(false);
     });
 
-    test('print', () => {
+    it('print', () => {
       // hm.print();
     });
   });
+
+  describe('HashMap HOF', () => {
+    let hashMap: LinkedHashMap;
+
+    beforeEach(() => {
+      hashMap = new LinkedHashMap<string, string>();
+      hashMap.set('key1', 'value1');
+      hashMap.set('key2', 'value2');
+      hashMap.set('key3', 'value3');
+    });
+
+    it('every() returns true if all elements match the condition', () => {
+      expect(hashMap.every(value => typeof value === 'string')).toBe(true);
+    });
+
+    it('some() returns true if any element matches the condition', () => {
+      expect(hashMap.some((value, key) => key === 'key1')).toBe(true);
+    });
+
+    it('forEach() should execute a function for each element', () => {
+      const mockCallback = jest.fn();
+      hashMap.forEach(mockCallback);
+      expect(mockCallback.mock.calls.length).toBe(3);
+    });
+
+    it('map() should transform each element', () => {
+      const newHashMap = hashMap.map(value => value.toUpperCase());
+      expect(newHashMap.get('key1')).toBe('VALUE1');
+    });
+
+    it('filter() should remove elements that do not match the condition', () => {
+      const filteredHashMap = hashMap.filter((value, key) => key !== 'key1');
+      expect(filteredHashMap.has('key1')).toBe(false);
+    });
+
+    it('reduce() should accumulate values', () => {
+      const result = hashMap.reduce((acc, value) => acc + value, '');
+      expect(result).toBe('value1value2value3');
+    });
+  });
 });

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

@@ -2,9 +2,15 @@ import { FibonacciHeap, Heap, MaxHeap, MinHeap } from '../../../../src';
 import { logBigOMetricsWrap } from '../../../utils';
 
 describe('Heap Operation Test', () => {
+  it('should initiate heap', function () {
+    const hp = new Heap<number>();
+    hp.add(1);
+    expect(hp.size).toBe(1);
+  });
+
   it('should heap add and delete work well', function () {
     const hp = new MinHeap<number>();
-
+    expect(hp.delete(1)).toBe(false);
     hp.add(2);
     hp.add(3);
     hp.add(1);
@@ -23,6 +29,7 @@ describe('Heap Operation Test', () => {
 
   it('should numeric heap work well', function () {
     const minNumHeap = new MinHeap<number>();
+    expect(minNumHeap.poll()).toBe(undefined);
     minNumHeap.add(1);
     minNumHeap.add(6);
     minNumHeap.add(2);
@@ -219,8 +226,47 @@ describe('Heap Operation Test', () => {
 
     expect([...heap.sort()]).toEqual([1, 3, 4, 5, 6, 7, 8]);
   });
+
+  it('should getter leaf', function () {
+    const hp = new Heap<number>();
+    expect(hp.leaf).toBe(undefined);
+    hp.add(1);
+    expect(hp.leaf).toBe(1);
+  });
+
+  it('should error', function () {
+    expect(() => {
+      new Heap([{ key: 1 }, { key: 2 }, { key: 3 }]);
+    }).toThrow(
+      "When comparing object types, a custom comparator must be defined in the constructor's options parameter."
+    );
+  });
 });
 
+describe('Heap HOF', () => {
+  let hp: Heap;
+
+  beforeEach(() => {
+    hp = new Heap([{ key: 1 }, { key: 2 }, { key: 3 }], { comparator: (a, b) => a.key - b.key });
+  });
+
+  it('should filter', () => {
+    const filtered = hp.filter(({ key }) => key % 2 === 1);
+    expect([...filtered]).toEqual([{ key: 1 }, { key: 3 }]);
+  });
+
+  it('should map', () => {
+    const mapped = hp.map(
+      ({ key }) => [key, key],
+      (a, b) => a[0] - b[0]
+    );
+    expect([...mapped]).toEqual([
+      [1, 1],
+      [2, 2],
+      [3, 3]
+    ]);
+  });
+});
 describe('FibonacciHeap', () => {
   let heap: FibonacciHeap<number>;
 
@@ -411,41 +457,3 @@ describe('FibonacciHeap Stress Test', () => {
     );
   });
 });
-
-// describe('Competitor performance compare', () => {
-//   const minHeap = new MinHeap<number>();
-//   const cHeap = new CHeap<number>();
-//   const cPQ = new PriorityQueue<number>(undefined, (a, b) => a - b);
-//   const n = 100000;
-//
-//   it('should add performance well', () => {
-//     const heapCost = calcRunTime(() => {
-//       for (let i = 0; i < n; i++) {
-//         minHeap.add(i);
-//       }
-//     })
-//
-//     console.log(`heapCost: ${heapCost}`)
-//   });
-//
-//   it('should add performance well', () => {
-//
-//     const cHeapCost = calcRunTime(() => {
-//       for (let i = 0; i < n; i++) {
-//         cHeap.push(i);
-//       }
-//     })
-//
-//     console.log(`cHeapCost: ${cHeapCost}`)
-//   });
-//
-//   it('should add performance well', () => {
-//
-//     const cPQCost = calcRunTime(() => {
-//       for (let i = 0; i < n; i++) {
-//         cPQ.push(i);
-//       }
-//     })
-//     console.log(`cPQCost: ${cPQCost}`)
-//   });
-// });

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

@@ -90,22 +90,22 @@ describe('Heap iterative methods', () => {
     }
   });
 
-  test('Heap is iterable', () => {
+  it('Heap is iterable', () => {
     expect([...heap]).toEqual([10, 20, 30, 40, 50, 60, 70, 80, 90, 100]);
   });
 
-  test('forEach method calls a function for each element', () => {
+  it('forEach method calls a function for each element', () => {
     const mockCallback = jest.fn();
     heap.forEach(mockCallback);
     expect(mockCallback.mock.calls.length).toBe(10);
   });
 
-  test('filter method returns filtered elements', () => {
+  it('filter method returns filtered elements', () => {
     const result = heap.filter(x => x > 50);
     expect([...result]).toEqual([60, 70, 80, 90, 100]);
   });
 
-  test('map method correctly maps elements', () => {
+  it('map method correctly maps elements', () => {
     const result = heap.map(
       x => x / 10,
       (a: number, b: number) => a - b
@@ -113,7 +113,7 @@ describe('Heap iterative methods', () => {
     expect([...result]).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
   });
 
-  test('reduce method correctly reduces elements', () => {
+  it('reduce method correctly reduces elements', () => {
     const result = heap.reduce((acc, curr) => acc + curr, 0);
     expect(result).toBe(550); // 10+20+...+100 = 550
   });

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

@@ -20,14 +20,27 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(list.getNodeAt(-1)).toBe(undefined);
     expect(list.getNodeAt(5)).toBe(undefined);
     expect(list.addAt(5, 6)).toBe(true);
+    expect(list.addAt(-1, 6)).toBe(false);
+    expect(list.addAt(7, 6)).toBe(false);
+    expect(list.addAt(100, 6)).toBe(false);
   });
 
   it('should addBefore', () => {
     expect(list.addBefore(1, 0)).toBe(true);
+    expect(list.addBefore(list.getNode(1)!, 2)).toBe(true);
+    expect([...list]).toEqual([0, 2, 1, 2, 3, 4, 5]);
   });
 
   it('should deleteAt', () => {
-    expect(list.deleteAt(1)).toBeTruthy();
+    expect(list.deleteAt(1)).toBe(true);
+    expect(list.deleteAt(-1)).toBe(false);
+    expect(list.deleteAt(list.size)).toBe(false);
+    expect(list.size).toBe(4);
+    expect(list.deleteAt(4)).toBe(false);
+    expect([...list]).toEqual([1, 3, 4, 5]);
+    expect(list.isEmpty()).toBe(false);
+    expect(list.deleteAt(3)).toBe(true);
+    expect([...list]).toEqual([1, 3, 4]);
   });
 
   it('should delete tail', () => {
@@ -52,6 +65,7 @@ describe('DoublyLinkedList Operation Test', () => {
     dList.delete('5');
     expect([...dList]).toEqual(['1', '6', '0', '9']);
     expect([...cloned]).toEqual(['1', '6', '0', '5', '9']);
+    expect(cloned.print()).toEqual(['1', '6', '0', '5', '9']);
   });
 
   it('should find undefined', () => {
@@ -94,6 +108,13 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(list.tail).toBe(undefined);
   });
 
+  it('should initialize with toElementFn', () => {
+    const dl = new DoublyLinkedList([{ key: 1 }, { key: 2 }, { key: 3 }], { toElementFn: ({ key }) => key });
+    expect([...dl]).toEqual([1, 2, 3]);
+    expect(dl.first).toBe(1);
+    expect(dl.last).toBe(3);
+  });
+
   it('should push elements to the list', () => {
     list.push(1);
     list.push(2);
@@ -111,8 +132,13 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(list.size).toBe(1);
     expect(list.head!.value).toBe(1);
     expect(list.tail!.value).toBe(1);
+    list.pop();
+    expect([...list]).toEqual([]);
+    list.pop();
+    expect([...list]).toEqual([]);
   });
   it('should insert elements at specific positions', () => {
+    expect(list.at(0)).toBe(undefined);
     list.push(1);
     list.push(2);
     list.push(3);
@@ -134,6 +160,8 @@ describe('DoublyLinkedList Operation Test', () => {
     expect(list.size).toBe(6);
     expect(list.at(5)).toBe(4);
     expect(list.tail!.value).toBe(4);
+    expect(list.at(-1)).toBe(undefined);
+    expect(list.at(6)).toBe(undefined);
   });
 
   it('should delete elements at specific positions', () => {
@@ -445,9 +473,11 @@ describe('iterable methods', () => {
     expect(dl.reduce((accumulator, element) => accumulator + element, 0)).toEqual(6);
   });
 
-  test('values', () => {
+  it('values', () => {
     const dl = new DoublyLinkedList<number>();
-    dl.push(1);
+    dl.shift();
+    expect([...dl]).toEqual([]);
+    dl.unshift(1);
     dl.push(2);
     dl.push(3);
     dl.delete(2);
@@ -458,7 +488,7 @@ describe('iterable methods', () => {
     expect([...dl.values()]).toEqual([3, 1]);
   });
 
-  test('some', () => {
+  it('some', () => {
     const dl = new DoublyLinkedList<number>();
     dl.push(1);
     dl.push(2);