directed-graph-typed 1.48.0 → 1.49.0

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

@@ -7,9 +7,248 @@
  */
 
 import { isWeakKey, rangeCheck } from '../../utils';
-import { HashMapLinkedNode, HashMapOptions } from '../../types';
+import { EntryCallback, HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
+import { IterableEntryBase } from "../base";
 
-export class HashMap<K = any, V = any> {
+export class HashMap<K = any, V = any> 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 elements and options.
+   * @param elements - The `elements` 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:
+   */
+  constructor(elements: Iterable<[K, V]> = [], options?: {
+    hashFn: (key: K) => string
+  }) {
+    super();
+    if (options) {
+      const { hashFn } = options;
+      if (hashFn) {
+        this._hashFn = hashFn;
+
+      }
+    }
+    if (elements) {
+      this.setMany(elements);
+    }
+  }
+
+  protected _size = 0;
+
+  get size(): number {
+    return this._size;
+  }
+
+  isEmpty(): boolean {
+    return this.size === 0;
+  }
+
+  clear() {
+    this._store = {};
+    this._objMap.clear();
+    this._size = 0;
+  }
+
+  /**
+   * The `set` function adds a key-value pair to a map-like data structure, incrementing the size if
+   * the key is not already present.
+   * @param {K} key - The key parameter is the key used to identify the value in the data structure. It
+   * can be of any type, but if it is an object, it will be stored in a Map, otherwise it will be
+   * stored in a regular JavaScript object.
+   * @param {V} value - The value parameter represents the value that you want to associate with the
+   * key in the data structure.
+   */
+  set(key: K, value: V) {
+
+    if (this._isObjKey(key)) {
+      if (!this._objMap.has(key)) {
+        this._size++;
+      }
+      this._objMap.set(key, value);
+
+    } else {
+      const strKey = this._getNoObjKey(key);
+      if (this._store[strKey] === undefined) {
+        this._size++;
+      }
+      this._store[strKey] = { key, value };
+    }
+  }
+
+  /**
+   * The function "setMany" sets multiple key-value pairs in a map.
+   * @param elements - The `elements` parameter is an iterable containing key-value pairs. Each
+   * key-value pair is represented as an array with two elements: the key and the value.
+   */
+  setMany(elements: Iterable<[K, V]>) {
+    for (const [key, value] of elements) this.set(key, value);
+  }
+
+  /**
+   * The `get` function retrieves a value from a map based on a given key, either from an object map or
+   * a string map.
+   * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
+   * of any type, but it should be compatible with the key type used when the map was created.
+   * @returns The method `get(key: K)` returns a value of type `V` if the key exists in the `_objMap`
+   * or `_store`, otherwise it returns `undefined`.
+   */
+  get(key: K): V | undefined {
+    if (this._isObjKey(key)) {
+      return this._objMap.get(key);
+    } else {
+      const strKey = this._getNoObjKey(key);
+      return this._store[strKey]?.value;
+    }
+  }
+
+  /**
+   * The `has` function checks if a given key exists in the `_objMap` or `_store` based on whether it
+   * is an object key or not.
+   * @param {K} key - The parameter "key" is of type K, which means it can be any type.
+   * @returns The `has` method is returning a boolean value.
+   */
+  has(key: K): boolean {
+    if (this._isObjKey(key)) {
+      return this._objMap.has(key);
+    } else {
+      const strKey = this._getNoObjKey(key);
+      return strKey in this._store;
+    }
+  }
+
+  /**
+   * The `delete` function removes an element from a map-like data structure based on the provided key.
+   * @param {K} key - The `key` parameter is the key of the element that you want to delete from the
+   * data structure.
+   * @returns The `delete` method returns a boolean value. It returns `true` if the key was
+   * successfully deleted from the map, and `false` if the key was not found in the map.
+   */
+  delete(key: K): boolean {
+    if (this._isObjKey(key)) {
+      if (this._objMap.has(key)) {
+        this._size--
+      }
+
+      return this._objMap.delete(key);
+    } else {
+      const strKey = this._getNoObjKey(key);
+      if (strKey in this._store) {
+        delete this._store[strKey];
+        this._size--;
+        return true;
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `map` function in TypeScript creates a new HashMap by applying a callback function to each
+   * key-value pair in the original HashMap.
+   * @param callbackfn - The callback function that will be called for each key-value pair in the
+   * HashMap. It takes four parameters:
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+   * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+   * be passed as the `this` value to the `callbackfn` function. If `thisArg
+   * @returns The `map` method is returning a new `HashMap` object with the transformed values based on
+   * the provided callback function.
+   */
+  map<U>(callbackfn: EntryCallback<K, V, U>, thisArg?: any): HashMap<K, U> {
+    const resultMap = new HashMap<K, U>();
+    let index = 0;
+    for (const [key, value] of this) {
+      resultMap.set(key, callbackfn.call(thisArg, value, key, index++, this));
+    }
+    return resultMap;
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `filter` function creates a new HashMap containing key-value pairs from the original HashMap
+   * that satisfy a given predicate function.
+   * @param predicate - The predicate parameter is a function that takes four arguments: value, key,
+   * index, and map. It is used to determine whether an element should be included in the filtered map
+   * or not. The function should return a boolean value - true if the element should be included, and
+   * false otherwise.
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+   * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+   * passed as the `this` value to the `predicate` function. If `thisArg` is
+   * @returns The `filter` method is returning a new `HashMap` object that contains the key-value pairs
+   * from the original `HashMap` that pass the provided `predicate` function.
+   */
+  filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): HashMap<K, V> {
+    const filteredMap = new HashMap<K, V>();
+    let index = 0;
+    for (const [key, value] of this) {
+      if (predicate.call(thisArg, value, key, index++, this)) {
+        filteredMap.set(key, value);
+      }
+    }
+    return filteredMap;
+  }
+
+  print(): void {
+    console.log([...this.entries()]);
+  }
+
+  /**
+   * The function returns an iterator that yields key-value pairs from both an object store and an
+   * object map.
+   */
+  protected* _getIterator(): IterableIterator<[K, V]> {
+    for (const node of Object.values(this._store)) {
+      yield [node.key, node.value] as [K, V];
+    }
+    for (const node of this._objMap) {
+      yield node as [K, V];
+    }
+  }
+
+  protected _hashFn: (key: K) => string = (key: K) => String(key);
+
+  protected _isObjKey(key: any): key is (object | ((...args: any[]) => any)) {
+    const keyType = typeof key;
+    return (keyType === 'object' || keyType === 'function') && key !== null
+  }
+
+  protected _getNoObjKey(key: K): string {
+    const keyType = typeof key;
+
+    let strKey: string;
+    if (keyType !== "string" && keyType !== "number" && keyType !== "symbol") {
+      strKey = this._hashFn(key);
+    } else {
+      if (keyType === "number") {
+        // TODO numeric key should has its own hash
+        strKey = <string>key;
+      } else {
+        strKey = <string>key;
+      }
+    }
+    return strKey;
+  }
+}
+
+export class LinkedHashMap<K = any, V = any> extends IterableEntryBase<K, V> {
 
   protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>> = {};
   protected _objMap = new WeakMap<object, HashMapLinkedNode<K, V | undefined>>();
@@ -25,6 +264,7 @@ export class HashMap<K = any, V = any> {
     hashFn: (key: K) => String(key),
     objHashFn: (key: K) => (<object>key)
   }) {
+    super();
     this._sentinel = <HashMapLinkedNode<K, V>>{};
     this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
 
@@ -108,49 +348,64 @@ export class HashMap<K = any, V = any> {
    */
   set(key: K, value?: V) {
     let node;
+    const isNewKey = !this.has(key); // Check if the key is new
 
     if (isWeakKey(key)) {
       const hash = this._objHashFn(key);
       node = this._objMap.get(hash);
 
-      if (node) {
-        // If the node already exists, update its value
-        node.value = value;
-      } else {
+      if (!node && isNewKey) {
         // Create new node
         node = { key: <K>hash, value, prev: this._tail, next: this._sentinel };
-
-        // Add new nodes to _objMap and linked list
         this._objMap.set(hash, node);
+      } else if (node) {
+        // Update the value of an existing node
+        node.value = value;
       }
     } else {
       const hash = this._hashFn(key);
-      // Non-object keys are handled in the same way as the original implementation
       node = this._noObjMap[hash];
-      if (node) {
+
+      if (!node && isNewKey) {
+        this._noObjMap[hash] = node = { key, value, prev: this._tail, next: this._sentinel };
+      } else if (node) {
+        // Update the value of an existing node
         node.value = value;
+      }
+    }
+
+    if (node && isNewKey) {
+      // Update the head and tail of the linked list
+      if (this._size === 0) {
+        this._head = node;
+        this._sentinel.next = node;
       } else {
-        this._noObjMap[hash] = node = {
-          key,
-          value,
-          prev: this._tail,
-          next: this._sentinel
-        };
+        this._tail.next = node;
+        node.prev = this._tail; // Make sure that the prev of the new node points to the current tail node
       }
+      this._tail = node;
+      this._sentinel.prev = node;
+      this._size++;
     }
 
-    if (this._size === 0) {
-      this._head = node;
-      this._sentinel.next = node;
+    return this._size;
+  }
+
+  has(key: K): boolean {
+    if (isWeakKey(key)) {
+      const hash = this._objHashFn(key);
+      return this._objMap.has(hash);
     } else {
-      this._tail.next = node;
+      const hash = this._hashFn(key);
+      return hash in this._noObjMap;
     }
+  }
 
-    this._tail = node;
-    this._sentinel.prev = node;
-    this._size++;
-
-    return this._size;
+  setMany(entries: Iterable<[K, V]>): void {
+    for (const entry of entries) {
+      const [key, value] = entry;
+      this.set(key, value);
+    }
   }
 
   /**
@@ -283,37 +538,40 @@ export class HashMap<K = any, V = any> {
     this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
   }
 
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the HashMap.
-   * Space Complexity: O(1)
-   *
-   * The `forEach` function iterates over each element in a HashMap and executes a callback function on
-   * each element.
-   * @param callback - The callback parameter is a function that will be called for each element in the
-   * HashMap. It takes three arguments:
-   */
-  forEach(callback: (element: [K, V], index: number, hashMap: HashMap<K, V>) => void) {
-    let index = 0;
-    let node = this._head;
-    while (node !== this._sentinel) {
-      callback(<[K, V]>[node.key, node.value], index++, this);
-      node = node.next;
+  clone(): LinkedHashMap<K, V> {
+    const cloned = new LinkedHashMap<K, V>([], { hashFn: this._hashFn, objHashFn: this._objHashFn });
+    for (const entry of this) {
+      const [key, value] = entry;
+      cloned.set(key, value);
     }
+    return cloned;
   }
 
   /**
-   * The `filter` function takes a predicate function and returns a new HashMap containing only the
-   * key-value pairs that satisfy the predicate.
-   * @param predicate - The `predicate` parameter is a function that takes two arguments: `element` and
-   * `map`.
-   * @returns a new HashMap object that contains the key-value pairs from the original HashMap that
-   * satisfy the given predicate function.
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    */
-  filter(predicate: (element: [K, V], index: number, map: HashMap<K, V>) => boolean): HashMap<K, V> {
-    const filteredMap = new HashMap<K, V>();
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `filter` function creates a new `LinkedHashMap` containing key-value pairs from the original
+   * map that satisfy a given predicate function.
+   * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
+   * `value`, `key`, `index`, and `this`. It should return a boolean value indicating whether the
+   * current element should be included in the filtered map or not.
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+   * specify the value of `this` within the `predicate` function. It is used when you want to bind a
+   * specific object as the context for the `predicate` function. If `thisArg` is not provided, `this
+   * @returns a new `LinkedHashMap` object that contains the key-value pairs from the original
+   * `LinkedHashMap` object that satisfy the given predicate function.
+   */
+  filter(predicate: EntryCallback<K, V, boolean>, thisArg?: any): LinkedHashMap<K, V> {
+    const filteredMap = new LinkedHashMap<K, V>();
     let index = 0;
     for (const [key, value] of this) {
-      if (predicate([key, value], index, this)) {
+      if (predicate.call(thisArg, value, key, index, this)) {
         filteredMap.set(key, value);
       }
       index++;
@@ -322,63 +580,56 @@ export class HashMap<K = any, V = any> {
   }
 
   /**
-   * The `map` function takes a callback function and returns a new HashMap with the values transformed
-   * by the callback.
-   * @param callback - The `callback` parameter is a function that takes two arguments: `element` and
-   * `map`.
-   * @returns a new HashMap object with the values mapped according to the provided callback function.
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `map` function in TypeScript creates a new `LinkedHashMap` by applying a callback function to
+   * each key-value pair in the original map.
+   * @param callback - The callback parameter is a function that will be called for each key-value pair
+   * in the map. It takes four arguments: the value of the current key-value pair, the key of the
+   * current key-value pair, the index of the current key-value pair, and the map itself. The callback
+   * function should
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+   * specify the value of `this` within the callback function. If provided, the callback function will
+   * be called with `thisArg` as its `this` value. If not provided, `this` will refer to the current
+   * map
+   * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
+   * function.
    */
-  map<NV>(callback: (element: [K, V], index: number, map: HashMap<K, V>) => NV): HashMap<K, NV> {
-    const mappedMap = new HashMap<K, NV>();
+  map<NV>(callback: EntryCallback<K, V, NV>, thisArg?: any): LinkedHashMap<K, NV> {
+    const mappedMap = new LinkedHashMap<K, NV>();
     let index = 0;
     for (const [key, value] of this) {
-      const newValue = callback([key, value], index, this);
+      const newValue = callback.call(thisArg, value, key, index, this);
       mappedMap.set(key, newValue);
       index++;
     }
     return mappedMap;
   }
 
-  /**
-   * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
-   * each element, accumulating a single value.
-   * @param callback - The callback parameter is a function that takes three arguments: accumulator,
-   * element, and map. It is called for each element in the HashMap and is used to accumulate a single
-   * result.
-   * @param {A} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
-   * is the value that will be passed as the first argument to the `callback` function when reducing
-   * the elements of the map.
-   * @returns The `reduce` function is returning the final value of the accumulator after iterating
-   * over all the elements in the HashMap and applying the callback function to each element.
-   */
-  reduce<A>(callback: (accumulator: A, element: [K, V], index: number, map: HashMap<K, V>) => A, initialValue: A): A {
-    let accumulator = initialValue;
-    let index = 0;
-    for (const entry of this) {
-      accumulator = callback(accumulator, entry, index, this);
-      index++;
-    }
-    return accumulator;
+  print() {
+    console.log([...this]);
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the HashMap.
+   * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
    * Space Complexity: O(1)
    *
    * The above function is an iterator that yields key-value pairs from a linked list.
    */
-  * [Symbol.iterator]() {
+  protected* _getIterator() {
     let node = this._head;
     while (node !== this._sentinel) {
-      yield <[K, V]>[node.key, node.value];
+      yield [node.key, node.value] as [K, V];
       node = node.next;
     }
   }
 
-  print() {
-    console.log([...this]);
-  }
-
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)

package/src/data-structures/heap/heap.ts

@@ -5,13 +5,15 @@
  * @license MIT License
  */
 
-import type { Comparator, DFSOrderPattern } from '../../types';
+import type { Comparator, DFSOrderPattern, ElementCallback } from '../../types';
 import { HeapOptions } from "../../types";
+import { IterableElementBase } from "../base";
 
-export class Heap<E = any> {
+export class Heap<E = any> extends IterableElementBase<E> {
   options: HeapOptions<E>;
 
   constructor(elements?: Iterable<E>, options?: HeapOptions<E>) {
+    super();
     const defaultComparator = (a: E, b: E) => {
       if (!(typeof a === 'number' && typeof b === 'number')) {
         throw new Error('The a, b params of compare function must be number');
@@ -339,56 +341,75 @@ export class Heap<E = any> {
     for (let i = Math.floor(this.size / 2); i >= 0; i--) this._sinkDown(i, this.elements.length >> 1);
   }
 
-  * [Symbol.iterator]() {
-    for (const element of this.elements) {
-      yield element;
-    }
-  }
-
-  forEach(callback: (element: E, index: number, heap: this) => void): void {
-    let index = 0;
-    for (const el of this) {
-      callback(el, index, this);
-      index++;
-    }
-  }
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
 
-  filter(predicate: (element: E, index: number, heap: Heap<E>) => boolean): Heap<E> {
-    const filteredHeap: Heap<E> = new Heap<E>([], this.options);
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `filter` function creates a new Heap object containing elements that pass a given callback
+   * function.
+   * @param callback - The `callback` parameter is a function that will be called for each element in
+   * the heap. It takes three arguments: the current element, the index of the current element, and the
+   * heap itself. The callback function should return a boolean value indicating whether the current
+   * element should be included in the filtered list
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+   * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
+   * passed as the `this` value to the `callback` function. If `thisArg` is
+   * @returns The `filter` method is returning a new `Heap` object that contains the elements that pass
+   * the filter condition specified by the `callback` function.
+   */
+  filter(callback: ElementCallback<E, boolean>, thisArg?: any): Heap<E> {
+    const filteredList = new Heap<E>();
     let index = 0;
-    for (const el of this) {
-      if (predicate(el, index, this)) {
-        filteredHeap.push(el);
+    for (const current of this) {
+      if (callback.call(thisArg, current, index, this)) {
+        filteredList.push(current);
       }
       index++;
     }
-    return filteredHeap;
+    return filteredList;
   }
 
-  map<T>(callback: (element: E, index: number, heap: Heap<E>) => T, comparator: Comparator<T>): Heap<T> {
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `map` function creates a new heap by applying a callback function to each element of the
+   * original heap.
+   * @param callback - The callback parameter is a function that will be called for each element in the
+   * original heap. It takes three arguments: the current element, the index of the current element,
+   * and the original heap itself. The callback function should return a value of type T, which will be
+   * added to the mapped heap.
+   * @param comparator - The `comparator` parameter is a function that is used to compare elements in
+   * the heap. It takes two arguments, `a` and `b`, and returns a negative number if `a` is less than
+   * `b`, a positive number if `a` is greater than `b`, or
+   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
+   * specify the value of `this` within the callback function. It is used when you want to bind a
+   * specific object as the context for the callback function. If `thisArg` is not provided,
+   * `undefined` is used as
+   * @returns a new instance of the Heap class, which is created using the mapped elements from the
+   * original Heap.
+   */
+  map<T>(callback: ElementCallback<E, T>, comparator: Comparator<T>, thisArg?: any): Heap<T> {
 
     const mappedHeap: Heap<T> = new Heap<T>([], { comparator: comparator });
     let index = 0;
     for (const el of this) {
-      mappedHeap.add(callback(el, index, this));
+      mappedHeap.add(callback.call(thisArg, el, index, this));
       index++;
     }
     return mappedHeap;
   }
 
-  reduce<T>(
-    callback: (accumulator: T, currentValue: E, currentIndex: number, heap: Heap<E>) => T,
-    initialValue: T
-  ): T {
-    let accumulator: T = initialValue;
-    let index = 0;
-    for (const el of this) {
-      accumulator = callback(accumulator, el, index, this);
-      index++;
-    }
-    return accumulator;
-  }
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -398,6 +419,12 @@ export class Heap<E = any> {
     console.log([...this]);
   }
 
+  protected* _getIterator() {
+    for (const element of this.elements) {
+      yield element;
+    }
+  }
+
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(1)

package/src/data-structures/index.ts

@@ -9,3 +9,4 @@ export * from './heap';
 export * from './priority-queue';
 export * from './matrix';
 export * from './trie';
+export * from './base';