data-structure-typed 1.49.8 → 1.50.0

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

@@ -21,29 +21,46 @@ import { isWeakKey, rangeCheck } from '../../utils';
  * 3. Unique Keys: Keys are unique. If you try to insert another entry with the same key, the old entry will be replaced by the new one.
  * 4. Unordered Collection: HashMap does not guarantee the order of entries, and the order may change over time.
  */
-export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
+export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K, V> {
   protected _store: { [key: string]: HashMapStoreItem<K, V> } = {};
   protected _objMap: Map<object, V> = new Map();
 
   /**
-   * The constructor function initializes a new instance of a class with optional entries and options.
-   * @param entries - The `entries` parameter is an iterable containing key-value pairs `[K, V]`. It
-   * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
-   * key-value pairs.
-   * @param [options] - The `options` parameter is an optional object that can contain additional
-   * configuration options for the constructor. In this case, it has one property:
+   * The constructor function initializes a HashMap object with an optional initial collection and
+   * options.
+   * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+   * `T`. It is an optional parameter and its default value is an empty array `[]`.
+   * @param [options] - The `options` parameter is an optional object that can contain two properties:
    */
-  constructor(entries: Iterable<[K, V]> = [], options?: HashMapOptions<K>) {
+  constructor(rawCollection: Iterable<R> = [], options?: HashMapOptions<K, V, R>) {
     super();
     if (options) {
-      const { hashFn } = options;
+      const { hashFn, toEntryFn } = options;
       if (hashFn) {
         this._hashFn = hashFn;
       }
+      if (toEntryFn) {
+        this._toEntryFn = toEntryFn;
+      }
     }
-    if (entries) {
-      this.setMany(entries);
+    if (rawCollection) {
+      this.setMany(rawCollection);
+    }
+  }
+
+  protected _toEntryFn: (rawElement: R) => [K, V] = (rawElement: R) => {
+    if (this.isEntry(rawElement)) {
+      // TODO, For performance optimization, it may be necessary to only inspect the first element traversed.
+      return rawElement;
+    } else {
+      throw new Error(
+        "If the provided rawCollection does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified."
+      );
     }
+  };
+
+  get toEntryFn() {
+    return this._toEntryFn;
   }
 
   protected _size = 0;
@@ -52,6 +69,10 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
     return this._size;
   }
 
+  isEntry(rawElement: any): rawElement is [K, V] {
+    return Array.isArray(rawElement) && rawElement.length === 2;
+  }
+
   isEmpty(): boolean {
     return this.size === 0;
   }
@@ -88,13 +109,18 @@ export class HashMap<K = any, V = any> extends IterableEntryBase<K, V> {
   }
 
   /**
-   * The function "setMany" sets multiple key-value pairs in a map.
-   * @param entries - The `entries` parameter is an iterable containing key-value pairs. Each
-   * key-value pair is represented as an array with two entries: the key and the value.
+   * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
+   * pair using a mapping function, and sets each key-value pair in the current object.
+   * @param rawCollection - The `rawCollection` parameter is an iterable collection of elements of type
+   * `T`.
+   * @returns The `setMany` function is returning an array of booleans.
    */
-  setMany(entries: Iterable<[K, V]>): boolean[] {
+  setMany(rawCollection: Iterable<R>): boolean[] {
     const results: boolean[] = [];
-    for (const [key, value] of entries) results.push(this.set(key, value));
+    for (const rawEle of rawCollection) {
+      const [key, value] = this.toEntryFn(rawEle);
+      results.push(this.set(key, value));
+    }
     return results;
   }
 

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

@@ -10,8 +10,9 @@ export type LinkedHashMapOptions<K> = {
   objHashFn?: (key: K) => object;
 };
 
-export type HashMapOptions<K> = {
+export type HashMapOptions<K, V, T> = {
   hashFn?: (key: K) => string;
+  toEntryFn?: (rawElement: T) => [K, V];
 };
 
 export type HashMapStoreItem<K, V> = { key: K; value: V };

package/test/integration/all-in-one.test.ts

@@ -23,7 +23,7 @@ describe('AVL Tree Test from data-structure-typed', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), 15);
+    node15 && tree.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;

package/test/integration/index.html

@@ -4,8 +4,8 @@
   <meta charset='UTF-8'>
   <title>CDN Test</title>
   <!--  <script src="../../dist/umd/data-structure-typed.min.js"></script>-->
-    <script src="../../dist/umd/data-structure-typed.js"></script>
-<!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed/dist/umd/data-structure-typed.min.js'></script>-->
+  <script src="../../dist/umd/data-structure-typed.js"></script>
+  <!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed/dist/umd/data-structure-typed.min.js'></script>-->
   <!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed@1.42.2/dist/umd/data-structure-typed.min.js'></script>-->
   <!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed@1.43.3/dist/umd/data-structure-typed.min.js'></script>-->
   <!--  <script src='https://cdn.jsdelivr.net/npm/data-structure-typed@1.44.0/dist/umd/data-structure-typed.min.js'></script>-->

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

@@ -1,11 +1,11 @@
 import { Deque } from '../../../../src';
 import { Deque as CDeque } from 'js-sdsl';
 import * as Benchmark from 'benchmark';
-import { magnitude } from '../../../utils';
+import { getRandomInt, magnitude } from '../../../utils';
 import { isCompetitor } from '../../../config';
 
 export const suite = new Benchmark.Suite();
-const { MILLION, HUNDRED_THOUSAND } = magnitude;
+const { MILLION, HUNDRED_THOUSAND, TEN_THOUSAND } = magnitude;
 
 suite.add(`${MILLION.toLocaleString()} push`, () => {
   const deque = new Deque<number>();
@@ -20,6 +20,12 @@ 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(getRandomInt(0, TEN_THOUSAND - 1));
+  })
   .add(`${MILLION.toLocaleString()} push & pop`, () => {
     const _deque = new Deque<number>();
 

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

@@ -24,7 +24,7 @@ describe('AVL Tree Test', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), node15);
+    node15 && tree.dfs(node => (subTreeSum += node.key), 'pre', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -132,7 +132,7 @@ describe('AVL Tree Test recursively', () => {
     expect(getMinNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && tree.subTreeTraverse(node => (subTreeSum += node.key), node15);
+    node15 && tree.dfs(node => (subTreeSum += node.key), 'pre', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;

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

@@ -238,16 +238,45 @@ describe('BinaryTree', () => {
     expect(tree.getNodes(tree.getNodeByKey(2), undefined, false, tree.root)).toEqual([tree.getNodeByKey(2)]);
   });
 
-  it('should subTreeTraverse', () => {
+  // it('should subTreeTraverse', () => {
+  //   tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
+  //   expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
+  //   expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.ITERATIVE, false)).toEqual([6, 3, 7]);
+  //   expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.RECURSIVE)).toEqual([6, 3, 7]);
+  //   expect(
+  //     tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.ITERATIVE, true)
+  //   ).toEqual([6, 3, 7, null]);
+  //   expect(
+  //     tree.subTreeTraverse(node => (node ? node.key : node), tree.getNode(6), IterationType.ITERATIVE, true)
+  //   ).toEqual([6, 3, 7, null]);
+  //   expect(
+  //     tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.RECURSIVE, true)
+  //   ).toEqual([6, 3, 7, null]);
+  // });
+
+  it('should sub tree traverse', () => {
     tree.addMany([4, 2, 6, null, 1, 3, null, 5, null, 7]);
-    expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
-    expect(tree.subTreeTraverse(node => node.key, tree.getNode(6), IterationType.RECURSIVE)).toEqual([6, 3, 7]);
-    expect(
-      tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.ITERATIVE, true)
-    ).toEqual([6, 3, 7, null]);
-    expect(
-      tree.subTreeTraverse(node => (node ? node.key : null), tree.getNode(6), IterationType.RECURSIVE, true)
-    ).toEqual([6, 3, 7, null]);
+    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), IterationType.ITERATIVE)).toEqual([6, 3, 7]);
+    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), IterationType.ITERATIVE, false)).toEqual([6, 3, 7]);
+    expect(tree.dfs(node => node.key, 'pre', tree.getNode(6), IterationType.RECURSIVE)).toEqual([6, 3, 7]);
+    expect(tree.dfs(node => (node ? node.key : null), 'pre', tree.getNode(6), IterationType.ITERATIVE, true)).toEqual([
+      6,
+      3,
+      7,
+      null
+    ]);
+    expect(tree.dfs(node => (node ? node.key : node), 'pre', tree.getNode(6), IterationType.ITERATIVE, true)).toEqual([
+      6,
+      3,
+      7,
+      null
+    ]);
+    expect(tree.dfs(node => (node ? node.key : null), 'pre', tree.getNode(6), IterationType.RECURSIVE, true)).toEqual([
+      6,
+      3,
+      7,
+      null
+    ]);
   });
 
   it('should clear the tree', () => {

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

@@ -54,7 +54,7 @@ describe('BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && bst.subTreeTraverse(node => (subTreeSum += node.key), 15);
+    node15 && bst.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -257,7 +257,7 @@ describe('BST operations test', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && objBST.subTreeTraverse(node => (subTreeSum += node.key), node15);
+    node15 && objBST.dfs(node => (subTreeSum += node.key), 'pre', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -444,7 +444,7 @@ describe('BST operations test recursively', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && bst.subTreeTraverse(node => (subTreeSum += node.key), 15);
+    node15 && bst.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -645,7 +645,7 @@ describe('BST operations test recursively', () => {
     expect(minNodeBySpecificNode?.key).toBe(12);
 
     let subTreeSum = 0;
-    node15 && objBST.subTreeTraverse(node => (subTreeSum += node.key), node15);
+    node15 && objBST.dfs(node => (subTreeSum += node.key), 'pre', node15);
     expect(subTreeSum).toBe(70);
 
     let lesserSum = 0;
@@ -868,14 +868,10 @@ describe('BST Performance test', function () {
   it('should subTreeTraverse, null should be ignored', () => {
     const bst = new BST();
     bst.addMany([4, 2, 6, 1, 3, 5, 7]);
-    expect(bst.subTreeTraverse(node => node.key, bst.getNode(6), IterationType.ITERATIVE)).toEqual([6, 5, 7]);
-    expect(bst.subTreeTraverse(node => node.key, bst.getNode(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
-    expect(bst.subTreeTraverse(node => node?.key ?? undefined, bst.getNode(6), IterationType.ITERATIVE, true)).toEqual([
-      6, 5, 7
-    ]);
-    expect(bst.subTreeTraverse(node => node?.key ?? undefined, bst.getNode(6), IterationType.RECURSIVE, true)).toEqual([
-      6, 5, 7
-    ]);
+    expect(bst.dfs(node => node.key, 'pre', bst.getNode(6), IterationType.ITERATIVE)).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node.key, 'pre', bst.getNode(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node?.key ?? undefined, 'pre', bst.getNode(6), IterationType.ITERATIVE)).toEqual([6, 5, 7]);
+    expect(bst.dfs(node => node?.key ?? undefined, 'pre', bst.getNode(6), IterationType.RECURSIVE)).toEqual([6, 5, 7]);
   });
 });
 

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

@@ -96,7 +96,7 @@ describe('TreeMultimap operations test1', () => {
     expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
-    node15 && treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (subTreeSum += node.key), 15);
+    node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode<number>) => (lesserSum += node.key), CP.lt, 10);
@@ -104,7 +104,7 @@ describe('TreeMultimap operations test1', () => {
 
     expect(node15 instanceof TreeMultimapNode);
     if (node15 instanceof TreeMultimapNode) {
-      const subTreeAdd = treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (node.count += 1), 15);
+      const subTreeAdd = treeMultimap.dfs(node => (node.count += 1), 'pre', 15);
       expect(subTreeAdd);
     }
     const node11 = treeMultimap.getNode(11);
@@ -350,7 +350,7 @@ describe('TreeMultimap operations test recursively1', () => {
     expect(minNodeBySpecificNode?.key).toBe(15);
 
     let subTreeSum = 0;
-    node15 && treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (subTreeSum += node.key), 15);
+    node15 && treeMultimap.dfs(node => (subTreeSum += node.key), 'pre', 15);
     expect(subTreeSum).toBe(31);
     let lesserSum = 0;
     treeMultimap.lesserOrGreaterTraverse((node: TreeMultimapNode<number>) => (lesserSum += node.key), CP.lt, 10);
@@ -358,7 +358,7 @@ describe('TreeMultimap operations test recursively1', () => {
 
     expect(node15 instanceof TreeMultimapNode);
     if (node15 instanceof TreeMultimapNode) {
-      const subTreeAdd = treeMultimap.subTreeTraverse((node: TreeMultimapNode<number>) => (node.count += 1), 15);
+      const subTreeAdd = treeMultimap.dfs(node => (node.count += 1), 'pre', 15);
       expect(subTreeAdd);
     }
     const node11 = treeMultimap.getNode(11);

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

@@ -110,6 +110,8 @@ describe('HashMap Test2', () => {
 
   test('Inheritability test', () => {
     class ExtendedHashMap<K, V> extends HashMap<K, V> {
+      someOtherParam?: string;
+
       constructor(
         elements: Iterable<[K, V]> = [],
         options?: {
@@ -118,8 +120,8 @@ describe('HashMap Test2', () => {
         }
       ) {
         const { someOtherParam, ...restOptions } = options || {};
-        // do something with someOtherParam
         super(elements, restOptions);
+        this.someOtherParam = someOtherParam;
       }
     }
 
@@ -128,6 +130,20 @@ describe('HashMap Test2', () => {
     expect(eHM.get('one')).toBe(1);
   });
 
+  test('should raw elements toEntry', () => {
+    const rawCollection = [
+      { id: 1, name: 'item 1' },
+      { id: 2, name: 'item 2' }
+    ];
+    const hm = new HashMap<number, string, { id: number; name: string }>(rawCollection, {
+      toEntryFn: rawElement => [rawElement.id, rawElement.name]
+    });
+
+    expect(hm.has(1)).toBe(true);
+    expect(hm.get(2)).toBe('item 2');
+    expect(hm.size).toBe(2);
+  });
+
   it('should update the value for an existing key', () => {
     hashMap.set('key1', 'value1');
     hashMap.set('key1', 'newValue');