data-structure-typed 1.47.3 → 1.47.5

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

@@ -3,20 +3,29 @@ import * as Benchmark from 'benchmark';
 import { magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
-const { TEN_THOUSAND } = magnitude;
+const { HUNDRED_THOUSAND, TEN_THOUSAND } = magnitude;
 
 suite
-  .add(`${TEN_THOUSAND.toLocaleString()} add & pop`, () => {
+  .add(`${HUNDRED_THOUSAND.toLocaleString()} add & pop`, () => {
     const heap = new Heap<number>({ comparator: (a, b) => b - a });
 
-    for (let i = 0; i < TEN_THOUSAND; i++) {
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
       heap.add(i);
     }
 
-    for (let i = 0; i < TEN_THOUSAND; i++) {
+    for (let i = 0; i < HUNDRED_THOUSAND; i++) {
       heap.pop();
     }
   })
+  .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++) {

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

@@ -8,7 +8,7 @@ describe('HashNode', () => {
 
     expect(hashNode.key).toBe(key);
     expect(hashNode.value).toBe(value);
-    expect(hashNode.next).toBe(null);
+    expect(hashNode.next).toBe(undefined);
   });
 });
 
@@ -16,7 +16,7 @@ describe('HashTable', () => {
   it('should initialize with default capacity', () => {
     const hashTable = new HashTable<string, string>();
     expect(hashTable.capacity).toBe(16);
-    expect(hashTable.buckets).toEqual(new Array(16).fill(null));
+    expect(hashTable.buckets).toEqual(new Array(16).fill(undefined));
     expect(hashTable.hashFn('a')).toBe(6);
     expect(hashTable.capacity).toBe(16);
     expect(hashTable.size).toBe(0);
@@ -184,3 +184,59 @@ describe('HashTable performance', function () {
     }
   });
 });
+
+
+describe('HashTable methods', () => {
+  let hashTable: HashTable<string, string>;
+
+  beforeEach(() => {
+    hashTable = new HashTable();
+    for (let i = 0; i < 10; i++) {
+      hashTable.set(`key${i}`, `value${i}`);
+    }
+  });
+
+  test('should retrieve correct values with get method', () => {
+    for (let i = 0; i < 10; i++) {
+      expect(hashTable.get(`key${i}`)).toBe(`value${i}`);
+    }
+  });
+
+  // test('forEach should apply a function to each key-value pair', () => {
+  //   const mockCallback = jest.fn();
+  //   hashTable.forEach(mockCallback);
+  //
+  //   expect(mockCallback.mock.calls.length).toBe(10);
+  //   for (let i = 0; i < 10; i++) {
+  //     // Check whether each key-value pair has been called before, regardless of the order
+  //     const call = mockCallback.mock.calls.find(call => call[1] === `value${i}`);
+  //     expect(call).toBeTruthy();
+  //     expect(call[0]).toBe(`key${i}`);
+  //   }
+  // });
+
+
+  test('filter should return a new HashTable with elements that satisfy the condition', () => {
+    const filtered = hashTable.filter(([key]) => key.endsWith('1') || key.endsWith('3'));
+
+    expect(filtered.size).toBe(2);
+    expect(filtered.get('key1')).toBe('value1');
+    expect(filtered.get('key3')).toBe('value3');
+  });
+
+  test('map should return a new HashTable with mapped values', () => {
+    const mapped = hashTable.map(([, value]) => value.toUpperCase());
+
+    for (let i = 0; i < 10; i++) {
+      expect(mapped.get(`key${i}`)).toBe(`value${i}`.toUpperCase());
+    }
+  });
+
+  test('reduce should accumulate values based on the reducer function', () => {
+    const result = hashTable.reduce((acc, [, value]) => `${acc}-${value}`, '');
+
+    expect(result).toBe('-value5-value7-value3-value4-value6-value0-value2-value8-value1-value9');
+  });
+
+});
+

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

@@ -49,4 +49,52 @@ describe('MinHeap', () => {
     minHeap.poll();
     expect(minHeap.isEmpty()).toBe(true);
   });
+
+
+  const n = 100000;
+
+  it('should push & dfs', () => {
+    for (let i = 0; i < n; i++) {
+      minHeap.push(i);
+    }
+    expect(minHeap.dfs()[0]).toBe(0)
+    expect(minHeap.dfs()[999]).toBe(4126)
+  });
+
+});
+
+describe('Heap iterative methods', () => {
+  let heap: MinHeap<number>;
+
+  beforeEach(() => {
+    heap = new MinHeap<number>();
+    for (let i = 1; i <= 10; i++) {
+      heap.add(i * 10); // Add 10, 20, ..., 100
+    }
+  });
+
+  test('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', () => {
+    const mockCallback = jest.fn();
+    heap.forEach(mockCallback);
+    expect(mockCallback.mock.calls.length).toBe(10);
+  });
+
+  test('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', () => {
+    const result = heap.map(x => x / 10, (a: number, b: number) => a - b);
+    expect([...result]).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+  });
+
+  test('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

@@ -166,7 +166,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.reverse();
 
     expect(list.toArray()).toEqual([3, 2, 1]);
-    expect(list.toArrayBackward()).toEqual([1, 2, 3]);
+    expect(list.toReversedArray()).toEqual([1, 2, 3]);
   });
 
   it('should map elements using a callback function', () => {
@@ -268,7 +268,7 @@ describe('DoublyLinkedList Operation Test', () => {
     list.push(2);
     list.push(3);
 
-    const reversedArray = list.toArrayBackward();
+    const reversedArray = list.toReversedArray();
 
     expect(reversedArray).toEqual([3, 2, 1]);
   });

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

@@ -205,3 +205,40 @@ describe('Queue Performance Test', () => {
     expect(performance.now() - startTime).toBeLessThan(bigO.LINEAR * 100);
   });
 });
+
+
+describe('Queue iterative methods', () => {
+  let queue: Queue<number>;
+
+  beforeEach(() => {
+    queue = new Queue();
+    for (let i = 0; i < 10; i++) {
+      queue.enqueue(i);
+    }
+  });
+
+  test('iterator should provide access to all elements', () => {
+    const elements = [];
+    for (const item of queue) {
+      elements.push(item);
+    }
+    expect(elements).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+  });
+
+  test('forEach should apply the callback to each element', () => {
+    const elements: number[] = [];
+    queue.forEach((element) => elements.push(element * 2));
+    expect(elements).toEqual([0, 2, 4, 6, 8, 10, 12, 14, 16, 18]);
+  });
+
+  test('filter should return a new queue with only the elements that satisfy the predicate', () => {
+    const filteredQueue = queue.filter(element => element % 2 === 0);
+    expect([...filteredQueue]).toEqual([0, 2, 4, 6, 8]);
+  });
+
+  test('map should return a new queue with the transformed elements', () => {
+    const mappedQueue = queue.map(element => element * 2);
+    expect([...mappedQueue]).toEqual([0, 2, 4, 6, 8, 10, 12, 14, 16, 18]);
+  });
+
+});

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

@@ -15,7 +15,7 @@ describe('Stack', () => {
     stack.push(1);
     stack.push(2);
     stack.push(3);
-    expect(stack.size()).toBe(3);
+    expect(stack.size).toBe(3);
   });
 
   it('should peek at the top element without removing it', () => {
@@ -23,7 +23,7 @@ describe('Stack', () => {
     stack.push(2);
     stack.push(3);
     expect(stack.peek()).toBe(3);
-    expect(stack.size()).toBe(3);
+    expect(stack.size).toBe(3);
   });
 
   it('should pop elements from the stack', () => {
@@ -32,7 +32,7 @@ describe('Stack', () => {
     stack.push(3);
     const poppedElement = stack.pop();
     expect(poppedElement).toBe(3);
-    expect(stack.size()).toBe(2);
+    expect(stack.size).toBe(2);
   });
 
   it('should return null when popping from an empty stack', () => {
@@ -53,7 +53,7 @@ describe('Stack', () => {
     stack.push(2);
     stack.push(3);
     stack.clear();
-    expect(stack.size()).toBe(0);
+    expect(stack.size).toBe(0);
     expect(stack.isEmpty()).toBe(true);
   });
 
@@ -61,7 +61,57 @@ describe('Stack', () => {
     stack.push(1);
     stack.push(2);
     const clonedStack = stack.clone();
-    expect(clonedStack.size()).toBe(2);
+    expect(clonedStack.size).toBe(2);
     expect(clonedStack.pop()).toBe(2);
   });
 });
+
+
+describe('Stack iterative methods', () => {
+  let stack: Stack<number>; // Declare a Stack instance
+
+  beforeEach(() => {
+    stack = new Stack<number>(); // Create a new Stack instance before each test
+    stack.push(1);
+    stack.push(2);
+    stack.push(3);
+  });
+
+  test('should iterate through the stack', () => {
+    const result: number[] = [];
+    for (const element of stack) {
+      result.push(element);
+    }
+
+    expect(result).toEqual([3, 2, 1]); // iteration should start from the top of the stack
+  });
+
+  test('should apply forEach to the stack', () => {
+    const result: number[] = [];
+    stack.forEach((element) => {
+      result.push(element);
+    });
+
+    expect(result).toEqual([3, 2, 1]);
+  });
+
+  test('should filter elements in the stack', () => {
+    const filteredStack = stack.filter((element) => element > 1);
+
+    expect(filteredStack.size).toBe(2);
+    expect([...filteredStack]).toEqual([2, 3]);
+  });
+
+  test('should map elements in the stack', () => {
+    const mappedStack = stack.map((element) => element * 2);
+
+    expect(mappedStack.size).toBe(3);
+    expect([...mappedStack]).toEqual([2, 4, 6]);
+  });
+
+  test('should reduce elements in the stack', () => {
+    const sum = stack.reduce((accumulator, element) => accumulator + element, 0);
+
+    expect(sum).toBe(6);
+  });
+});

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

@@ -823,3 +823,36 @@ describe('Trie operations', () => {
     expect(trie.getHeight()).toBe(6); // Assuming 'apple' and 'banana' are the longest words.
   });
 });
+
+describe('Trie class', () => {
+  let trie: Trie;
+  beforeEach(() => {
+    trie = new Trie(['apple', 'app', 'banana', 'band', 'bandana']);
+  });
+
+  test('[Symbol.iterator] should iterate over all words', () => {
+    const words = [...trie];
+    expect(words).toEqual(['app', 'apple', 'banana', 'band', 'bandana']);
+  });
+
+  test('forEach should execute a callback for each word', () => {
+    const mockCallback = jest.fn();
+    trie.forEach(mockCallback);
+    expect(mockCallback).toHaveBeenCalledTimes(5);
+  });
+
+  test('filter should return words that satisfy the predicate', () => {
+    const filteredWords = trie.filter(word => word.startsWith('ba'));
+    expect(filteredWords).toEqual(['banana', 'band', 'bandana']);
+  });
+
+  test('map should apply a function to each word', () => {
+    const mappedWords = trie.map(word => word.length.toString());
+    expect([...mappedWords]).toEqual(['3', '5', '6', '4', '7']);
+  });
+
+  test('reduce should reduce the words to a single value', () => {
+    const concatenatedWords = trie.reduce((acc, word) => acc + word, '');
+    expect(concatenatedWords).toEqual('appapplebananabandbandana');
+  });
+});