data-structure-typed 1.48.0 → 1.48.2

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

@@ -9,3 +9,5 @@ export type HashMapOptions<K> = {
   hashFn: (key: K) => string;
   objHashFn: (key: K) => object
 }
+
+export type HashMapStoreItem<K, V> = { key: K, value: V };

package/src/types/data-structures/index.ts

@@ -9,3 +9,4 @@ export * from './queue';
 export * from './stack';
 export * from './tree';
 export * from './trie';
+export * from './base';

package/test/integration/avl-tree.test.ts

@@ -2,10 +2,10 @@ import { AVLTree, CP } from 'avl-tree-typed';
 
 describe('AVL Tree Test', () => {
   it('should perform various operations on a AVL Tree', () => {
-    const arr = [11, 3, 15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
+    const arr: [number, number][] = [[11, 11], [3, 3], [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]];
     const tree = new AVLTree();
 
-    for (const i of arr) tree.add(i, i);
+    for (const i of arr) tree.add(i);
 
     const node6 = tree.get(6);
 

package/test/integration/bst.test.ts

@@ -4,10 +4,10 @@ describe('Individual package BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with numeric values', () => {
     const bst = new BST();
     expect(bst).toBeInstanceOf(BST);
-    bst.add(11, 11);
-    bst.add(3, 3);
+    bst.add([11, 11]);
+    bst.add([3, 3]);
     const idsOrValues = [15, 1, 8, 13, 16, 2, 6, 9, 12, 14, 4, 7, 10, 5];
-    bst.addMany(idsOrValues, idsOrValues, false);
+    bst.addMany(idsOrValues, false);
     expect(bst.root).toBeInstanceOf(BSTNode);
 
     if (bst.root) expect(bst.root.key).toBe(11);
@@ -185,30 +185,26 @@ describe('Individual package BST operations test', () => {
   it('should perform various operations on a Binary Search Tree with object values', () => {
     const objBST = new BST<{ key: number; keyA: number }>();
     expect(objBST).toBeInstanceOf(BST);
-    objBST.add(11, { key: 11, keyA: 11 });
-    objBST.add(3, { key: 3, keyA: 3 });
-    const values = [
-      { key: 15, keyA: 15 },
-      { key: 1, keyA: 1 },
-      { key: 8, keyA: 8 },
-      { key: 13, keyA: 13 },
-      { key: 16, keyA: 16 },
-      { key: 2, keyA: 2 },
-      { key: 6, keyA: 6 },
-      { key: 9, keyA: 9 },
-      { key: 12, keyA: 12 },
-      { key: 14, keyA: 14 },
-      { key: 4, keyA: 4 },
-      { key: 7, keyA: 7 },
-      { key: 10, keyA: 10 },
-      { key: 5, keyA: 5 }
+    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.map(item => item.key),
-      values,
-      false
-    );
+    objBST.addMany(values, false);
 
     expect(objBST.root).toBeInstanceOf(BSTNode);
 

package/test/performance/data-structures/binary-tree/binary-tree.test.ts

@@ -4,17 +4,17 @@ import { getRandomIntArray, magnitude } from '../../../utils';
 
 const suite = new Benchmark.Suite();
 const biTree = new BinaryTree<number>();
-const { N_LOG_N } = magnitude;
-const arr = getRandomIntArray(N_LOG_N, 0, N_LOG_N, true);
+const { THOUSAND } = magnitude;
+const arr = getRandomIntArray(THOUSAND, 0, THOUSAND, true);
 
 suite
-  .add(`${N_LOG_N.toLocaleString()} add randomly`, () => {
+  .add(`${THOUSAND.toLocaleString()} add randomly`, () => {
     biTree.clear();
     for (let i = 0; i < arr.length; i++) {
       biTree.add(arr[i]);
     }
   })
-  .add(`${N_LOG_N.toLocaleString()} add & delete randomly`, () => {
+  .add(`${THOUSAND.toLocaleString()} add & delete randomly`, () => {
     biTree.clear();
     for (let i = 0; i < arr.length; i++) {
       biTree.add(arr[i]);
@@ -23,23 +23,28 @@ suite
       biTree.delete(arr[i]);
     }
   })
-  .add(`${N_LOG_N.toLocaleString()} addMany`, () => {
+  .add(`${THOUSAND.toLocaleString()} addMany`, () => {
     biTree.clear();
     biTree.addMany(arr);
   })
-  .add(`${N_LOG_N.toLocaleString()} get`, () => {
+  .add(`${THOUSAND.toLocaleString()} get`, () => {
     for (let i = 0; i < arr.length; i++) {
       biTree.get(arr[i]);
     }
   })
-  .add(`${N_LOG_N.toLocaleString()} dfs`, () => {
-    for (let i = 0; i < N_LOG_N; i++) biTree.dfs();
+  .add(`${THOUSAND.toLocaleString()} has`, () => {
+    for (let i = 0; i < arr.length; i++) {
+      biTree.get(arr[i]);
+    }
+  })
+  .add(`${THOUSAND.toLocaleString()} dfs`, () => {
+    for (let i = 0; i < THOUSAND; i++) biTree.dfs();
   })
-  .add(`${N_LOG_N.toLocaleString()} bfs`, () => {
-    for (let i = 0; i < N_LOG_N; i++) biTree.bfs();
+  .add(`${THOUSAND.toLocaleString()} bfs`, () => {
+    for (let i = 0; i < THOUSAND; i++) biTree.bfs();
   })
-  .add(`${N_LOG_N.toLocaleString()} morris`, () => {
-    for (let i = 0; i < N_LOG_N; i++) biTree.morris(n => n, 'pre');
+  .add(`${THOUSAND.toLocaleString()} morris`, () => {
+    for (let i = 0; i < THOUSAND; i++) biTree.morris(n => n, 'pre');
   });
 
 export { suite };

package/test/unit/data-structures/binary-tree/avl-tree.test.ts

@@ -305,30 +305,30 @@ describe('AVLTree iterative methods test', () => {
 
   test('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    avl.forEach((entry) => {
-      mockCallback(entry);
+    avl.forEach((value, key) => {
+      mockCallback(value, key);
     });
 
     expect(mockCallback.mock.calls.length).toBe(3);
-    expect(mockCallback.mock.calls[0][0]).toEqual([1, 'a']);
-    expect(mockCallback.mock.calls[1][0]).toEqual([2, 'b']);
-    expect(mockCallback.mock.calls[2][0]).toEqual([3, 'c']);
+    expect(mockCallback.mock.calls[0]).toEqual(['a', 1]);
+    expect(mockCallback.mock.calls[1]).toEqual(['b', 2]);
+    expect(mockCallback.mock.calls[2]).toEqual(['c', 3]);
   });
 
   test('filter should return a new tree with filtered elements', () => {
-    const filteredTree = avl.filter(([key]) => key > 1);
+    const filteredTree = avl.filter((value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([[2, 'b'], [3, 'c']]);
   });
 
   test('map should return a new tree with modified elements', () => {
-    const mappedTree = avl.map(([key]) => (key * 2).toString());
+    const mappedTree = avl.map((value, key) => (key * 2).toString());
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
   });
 
   test('reduce should accumulate values', () => {
-    const sum = avl.reduce((acc, [key]) => acc + key, 0);
+    const sum = avl.reduce((acc, value, key) => acc + key, 0);
     expect(sum).toBe(6);
   });
 
@@ -341,4 +341,20 @@ describe('AVLTree iterative methods test', () => {
     expect(entries.length).toBe(3);
     expect(entries).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
   });
+
+  test('should clone work well', () => {
+    const cloned = avl.clone();
+    expect(cloned.root?.left?.key).toBe(1);
+    expect(cloned.root?.right?.value).toBe('c');
+  });
+
+  test('should keys', () => {
+    const keys = avl.keys();
+    expect([...keys]).toEqual([1, 2, 3]);
+  });
+
+  test('should values', () => {
+    const values = avl.values();
+    expect([...values]).toEqual(['a', 'b', 'c']);
+  });
 });

package/test/unit/data-structures/binary-tree/binary-tree.test.ts

@@ -564,7 +564,6 @@ describe('BinaryTree', () => {
   });
 });
 
-
 describe('BinaryTree iterative methods test', () => {
   let binaryTree: BinaryTree<string>;
   beforeEach(() => {
@@ -581,30 +580,30 @@ describe('BinaryTree iterative methods test', () => {
 
   test('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    binaryTree.forEach((entry) => {
-      mockCallback(entry);
+    binaryTree.forEach((value, key) => {
+      mockCallback(value, key);
     });
 
     expect(mockCallback.mock.calls.length).toBe(3);
-    expect(mockCallback.mock.calls[0][0]).toEqual([2, 'b']);
-    expect(mockCallback.mock.calls[1][0]).toEqual([1, 'a']);
-    expect(mockCallback.mock.calls[2][0]).toEqual([3, 'c']);
+    expect(mockCallback.mock.calls[0]).toEqual(['b', 2]);
+    expect(mockCallback.mock.calls[1]).toEqual(['a', 1]);
+    expect(mockCallback.mock.calls[2]).toEqual(['c', 3]);
   });
 
   test('filter should return a new tree with filtered elements', () => {
-    const filteredTree = binaryTree.filter(([key]) => key > 1);
+    const filteredTree = binaryTree.filter((value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([[3, 'c'], [2, 'b']]);
   });
 
   test('map should return a new tree with modified elements', () => {
-    const mappedTree = binaryTree.map(([key]) => (key * 2).toString());
+    const mappedTree = binaryTree.map((value, key) => (key * 2).toString());
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
   });
 
   test('reduce should accumulate values', () => {
-    const sum = binaryTree.reduce((acc, [key]) => acc + key, 0);
+    const sum = binaryTree.reduce((acc, currentValue, currentKey) => acc + currentKey, 0);
     expect(sum).toBe(6);
   });
 
@@ -617,4 +616,20 @@ describe('BinaryTree iterative methods test', () => {
     expect(entries.length).toBe(3);
     expect(entries).toEqual([[2, 'b'], [1, 'a'], [3, 'c']]);
   });
+
+  test('should clone work well', () => {
+    const cloned = binaryTree.clone();
+    expect(cloned.root?.left?.key).toBe(2);
+    expect(cloned.root?.right?.value).toBe('c');
+  });
+
+  test('should keys', () => {
+    const keys = binaryTree.keys();
+    expect([...keys]).toEqual([2, 1, 3]);
+  });
+
+  test('should values', () => {
+    const values = binaryTree.values();
+    expect([...values]).toEqual(['b', 'a', 'c']);
+  });
 });

package/test/unit/data-structures/binary-tree/bst.test.ts

@@ -864,30 +864,30 @@ describe('BST iterative methods test', () => {
 
   test('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    bst.forEach((entry) => {
-      mockCallback(entry);
+    bst.forEach((value, key) => {
+      mockCallback(value, key);
     });
 
     expect(mockCallback.mock.calls.length).toBe(3);
-    expect(mockCallback.mock.calls[0][0]).toEqual([1, 'a']);
-    expect(mockCallback.mock.calls[1][0]).toEqual([2, 'b']);
-    expect(mockCallback.mock.calls[2][0]).toEqual([3, 'c']);
+    expect(mockCallback.mock.calls[0]).toEqual(['a', 1]);
+    expect(mockCallback.mock.calls[1]).toEqual(['b', 2]);
+    expect(mockCallback.mock.calls[2]).toEqual(['c', 3]);
   });
 
   test('filter should return a new tree with filtered elements', () => {
-    const filteredTree = bst.filter(([key]) => key > 1);
+    const filteredTree = bst.filter((value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([[2, 'b'], [3, 'c']]);
   });
 
   test('map should return a new tree with modified elements', () => {
-    const mappedTree = bst.map(([key]) => (key * 2).toString());
+    const mappedTree = bst.map((value, key) => (key * 2).toString());
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
   });
 
   test('reduce should accumulate values', () => {
-    const sum = bst.reduce((acc, [key]) => acc + key, 0);
+    const sum = bst.reduce((acc, value, key) => acc + key, 0);
     expect(sum).toBe(6);
   });
 
@@ -900,4 +900,20 @@ describe('BST iterative methods test', () => {
     expect(entries.length).toBe(3);
     expect(entries).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
   });
+
+  test('should clone work well', () => {
+    const cloned = bst.clone();
+    expect(cloned.root?.left).toBe(undefined);
+    expect(cloned.root?.right?.value).toBe('b');
+  });
+
+  test('should keys', () => {
+    const keys = bst.keys();
+    expect([...keys]).toEqual([1, 2, 3]);
+  });
+
+  test('should values', () => {
+    const values = bst.values();
+    expect([...values]).toEqual(['a', 'b', 'c']);
+  });
 });

package/test/unit/data-structures/binary-tree/rb-tree.test.ts

@@ -524,30 +524,30 @@ describe('RedBlackTree iterative methods test', () => {
 
   test('forEach should iterate over all elements', () => {
     const mockCallback = jest.fn();
-    rbTree.forEach((entry) => {
-      mockCallback(entry);
+    rbTree.forEach((value, key) => {
+      mockCallback(value, key);
     });
 
     expect(mockCallback.mock.calls.length).toBe(3);
-    expect(mockCallback.mock.calls[0][0]).toEqual([1, 'a']);
-    expect(mockCallback.mock.calls[1][0]).toEqual([2, 'b']);
-    expect(mockCallback.mock.calls[2][0]).toEqual([3, 'c']);
+    expect(mockCallback.mock.calls[0]).toEqual(['a', 1]);
+    expect(mockCallback.mock.calls[1]).toEqual(['b', 2]);
+    expect(mockCallback.mock.calls[2]).toEqual(['c', 3]);
   });
 
   test('filter should return a new tree with filtered elements', () => {
-    const filteredTree = rbTree.filter(([key]) => key > 1);
+    const filteredTree = rbTree.filter((value, key) => key > 1);
     expect(filteredTree.size).toBe(2);
     expect([...filteredTree]).toEqual([[2, 'b'], [3, 'c']]);
   });
 
   test('map should return a new tree with modified elements', () => {
-    const mappedTree = rbTree.map(([key]) => (key * 2).toString());
+    const mappedTree = rbTree.map((value, key) => (key * 2).toString());
     expect(mappedTree.size).toBe(3);
     expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
   });
 
   test('reduce should accumulate values', () => {
-    const sum = rbTree.reduce((acc, [key]) => acc + key, 0);
+    const sum = rbTree.reduce((acc, value, key) => acc + key, 0);
     expect(sum).toBe(6);
   });
 

package/test/unit/data-structures/binary-tree/tree-multimap.test.ts

@@ -1,4 +1,12 @@
-import { CP, IterationType, TreeMultimap, TreeMultimapNode } from '../../../../src';
+import {
+  AVLTreeNode,
+  BinaryTreeNode,
+  BSTNode,
+  CP,
+  IterationType,
+  TreeMultimap,
+  TreeMultimapNode
+} from '../../../../src';
 import { isDebugTest } from '../../../config';
 
 const isDebug = isDebugTest;
@@ -592,3 +600,76 @@ describe('TreeMultimap Performance test', function () {
     isDebug && console.log('---lesserOrGreaterTraverse', performance.now() - startL);
   });
 });
+
+describe('TreeMultimap iterative methods test', () => {
+  let treeMM: TreeMultimap<string>;
+  beforeEach(() => {
+    treeMM = new TreeMultimap<string>();
+    treeMM.add([1, 'a'], 10);
+    treeMM.add([2, 'b'], 10);
+    treeMM.add([3, 'c'], 1);
+  });
+
+  test('The node obtained by get Node should match the node type', () => {
+    const node3 = treeMM.getNode(3);
+    expect(node3).toBeInstanceOf(BinaryTreeNode);
+    expect(node3).toBeInstanceOf(BSTNode);
+    expect(node3).toBeInstanceOf(AVLTreeNode);
+  });
+
+  test('forEach should iterate over all elements', () => {
+    const mockCallback = jest.fn();
+    treeMM.forEach((value, key) => {
+      mockCallback(value, key);
+    });
+
+    expect(mockCallback.mock.calls.length).toBe(3);
+    expect(mockCallback.mock.calls[0]).toEqual(['a', 1]);
+    expect(mockCallback.mock.calls[1]).toEqual(['b', 2]);
+    expect(mockCallback.mock.calls[2]).toEqual(['c', 3]);
+  });
+
+  test('filter should return a new tree with filtered elements', () => {
+    const filteredTree = treeMM.filter((value, key) => key > 1);
+    expect(filteredTree.size).toBe(2);
+    expect([...filteredTree]).toEqual([[2, 'b'], [3, 'c']]);
+  });
+
+  test('map should return a new tree with modified elements', () => {
+    const mappedTree = treeMM.map((value, key) => (key * 2).toString());
+    expect(mappedTree.size).toBe(3);
+    expect([...mappedTree]).toEqual([[1, '2'], [2, '4'], [3, '6']]);
+  });
+
+  test('reduce should accumulate values', () => {
+    const sum = treeMM.reduce((acc, value, key) => acc + key, 0);
+    expect(sum).toBe(6);
+  });
+
+  test('[Symbol.iterator] should provide an iterator', () => {
+    const entries = [];
+    for (const entry of treeMM) {
+      entries.push(entry);
+    }
+
+    expect(entries.length).toBe(3);
+    expect(entries).toEqual([[1, 'a'], [2, 'b'], [3, 'c']]);
+  });
+
+  test('should clone work well', () => {
+    expect(treeMM.count).toBe(21)
+    const cloned = treeMM.clone();
+    expect(cloned.root?.left?.key).toBe(1);
+    expect(cloned.root?.right?.value).toBe('c');
+  });
+
+  test('should keys', () => {
+    const keys = treeMM.keys();
+    expect([...keys]).toEqual([1, 2, 3]);
+  });
+
+  test('should values', () => {
+    const values = treeMM.values();
+    expect([...values]).toEqual(['a', 'b', 'c']);
+  });
+});

package/test/unit/data-structures/graph/directed-graph.test.ts

@@ -616,22 +616,22 @@ describe('DirectedGraph iterative Methods', () => {
 
   test('forEach should apply a function to each vertex', () => {
     const result: VertexKey[] = [];
-    graph.forEach(vertex => result.push(vertex[0]));
+    graph.forEach((value, key) => key && result.push(key));
     expect(result).toEqual(vertices);
   });
 
   test('filter should return vertices that satisfy the condition', () => {
-    const filtered = graph.filter(vertex => vertex[0] === 'A' || vertex[0] === 'B');
+    const filtered = graph.filter((value, vertex) => vertex === 'A' || vertex === 'B');
     expect(filtered).toEqual([["A", undefined], ["B", undefined]]);
   });
 
   test('map should apply a function to each vertex and return a new array', () => {
-    const mapped = graph.map(vertex => vertex[0] + '_mapped');
+    const mapped = graph.map((value, vertex) => vertex + '_mapped');
     expect(mapped).toEqual(vertices.map(v => v + '_mapped'));
   });
 
   test('reduce should accumulate a value based on each vertex', () => {
-    const concatenated = graph.reduce((acc, vertex) => acc + vertex[0], '');
+    const concatenated = graph.reduce((acc, value, key) => acc + key, '');
     expect(concatenated).toBe(vertices.join(''));
   });
 });