linked-list-typed 1.44.1 → 1.45.0

package/dist/data-structures/hash/hash-map.d.ts

@@ -1,4 +1,3 @@
-import { HashFunction } from '../../types';
 /**
  * data-structure-typed
  *
@@ -6,45 +5,239 @@ import { HashFunction } from '../../types';
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-export declare class HashMap<K, V> {
-    /**
-     * The constructor initializes the properties of a hash table, including the initial capacity, load factor, capacity
-     * multiplier, size, table array, and hash function.
-     * @param [initialCapacity=16] - The initial capacity is the initial size of the hash table. It determines the number of
-     * buckets or slots available for storing key-value pairs. The default value is 16.
-     * @param [loadFactor=0.75] - The load factor is a measure of how full the hash table can be before it is resized. It is
-     * a value between 0 and 1, where 1 means the hash table is completely full and 0 means it is completely empty. When the
-     * load factor is reached, the hash table will
-     * @param [hashFn] - The `hashFn` parameter is an optional parameter that represents the hash function used to calculate
-     * the index of a key in the hash table. If a custom hash function is not provided, a default hash function is used. The
-     * default hash function converts the key to a string, calculates the sum of the
-     */
-    constructor(initialCapacity?: number, loadFactor?: number, hashFn?: HashFunction<K>);
-    protected _initialCapacity: number;
-    get initialCapacity(): number;
-    protected _loadFactor: number;
-    get loadFactor(): number;
-    protected _capacityMultiplier: number;
-    get capacityMultiplier(): number;
+import { HashMapLinkedNode, HashMapOptions, IterateDirection } from "../../types";
+/**
+ * Because the implementation of HashMap relies on JavaScript's built-in objects and arrays,
+ * these underlying structures have already dealt with dynamic expansion and hash collisions.
+ * Therefore, there is no need for additional logic to handle these issues.
+ */
+export declare class HashMapIterator<K, V> {
+    readonly hashMap: HashMap<K, V>;
+    protected _node: HashMapLinkedNode<K, V>;
+    readonly iterateDirection: IterateDirection;
+    protected readonly _sentinel: HashMapLinkedNode<K, V>;
+    /**
+     * This is a constructor function for a linked list iterator in a HashMap data structure.
+     * @param node - The `node` parameter is a reference to a `HashMapLinkedNode` object. This object
+     * represents a node in a linked list used in a hash map data structure. It contains a key-value pair
+     * and references to the previous and next nodes in the linked list.
+     * @param sentinel - The `sentinel` parameter is a reference to a special node in a linked list. It
+     * is used to mark the beginning or end of the list and is typically used in data structures like
+     * hash maps or linked lists to simplify operations and boundary checks.
+     * @param hashMap - A HashMap object that stores key-value pairs.
+     * @param {IterateDirection} iterateDirection - The `iterateDirection` parameter is an optional
+     * parameter that specifies the direction in which the iterator should iterate over the elements of
+     * the HashMap. It can take one of the following values:
+     * @returns The constructor does not return anything. It is used to initialize the properties and
+     * methods of the object being created.
+     */
+    constructor(node: HashMapLinkedNode<K, V>, sentinel: HashMapLinkedNode<K, V>, hashMap: HashMap<K, V>, iterateDirection?: IterateDirection);
+    /**
+     * The above function returns a Proxy object that allows access to the key and value of a node in a
+     * data structure.
+     * @returns The code is returning a Proxy object.
+     */
+    get current(): [K, V];
+    /**
+     * The function checks if a node is accessible.
+     * @returns a boolean value indicating whether the `_node` is not equal to the `_sentinel`.
+     */
+    isAccessible(): boolean;
+    prev(): this;
+    next(): this;
+}
+export declare class HashMap<K = any, V = any> {
+    protected _nodes: HashMapLinkedNode<K, V>[];
+    protected _orgMap: Record<string, HashMapLinkedNode<K, V>>;
+    protected _head: HashMapLinkedNode<K, V>;
+    protected _tail: HashMapLinkedNode<K, V>;
+    protected readonly _sentinel: HashMapLinkedNode<K, V>;
+    readonly OBJ_KEY_INDEX: symbol;
     protected _size: number;
     get size(): number;
-    protected _table: Array<Array<[K, V]>>;
-    get table(): Array<Array<[K, V]>>;
-    protected _hashFn: HashFunction<K>;
-    get hashFn(): HashFunction<K>;
-    set(key: K, value: V): void;
-    get(key: K): V | undefined;
-    delete(key: K): void;
-    entries(): IterableIterator<[K, V]>;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
-    clear(): void;
+    /**
+     * The constructor initializes a HashMap object with an optional initial set of key-value pairs.
+     * @param hashMap - The `hashMap` parameter is an optional parameter of type `HashMapOptions<[K,
+     * V]>`. It is an array of key-value pairs, where each pair is represented as an array `[K, V]`. The
+     * `K` represents the type of the key and `V` represents the
+     */
+    constructor(hashMap?: HashMapOptions<[K, V]>);
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `set` function adds a new key-value pair to a data structure, either using an object key or a
+     * string key.
+     * @param {K} key - The `key` parameter is the key to be set in the data structure. It can be of any
+     * type, but typically it is a string or symbol.
+     * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
+     * value associated with the key being set in the data structure.
+     * @param {boolean} isObjectKey - A boolean flag indicating whether the key is an object key or not.
+     * @returns the size of the data structure after the key-value pair has been set.
+     */
+    set(key: K, value?: V, isObjectKey?: boolean): number;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `get` retrieves the value associated with a given key from a map, either by using the
+     * key directly or by using an index stored in the key object.
+     * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
+     * of any type, but typically it is a string or symbol.
+     * @param {boolean} isObjectKey - The `isObjectKey` parameter is a boolean flag that indicates
+     * whether the `key` parameter is an object key or not. If `isObjectKey` is `true`, it means that
+     * `key` is an object key. If `isObjectKey` is `false`, it means that `key`
+     * @returns The value associated with the given key is being returned. If the key is an object key,
+     * the value is retrieved from the `_nodes` array using the index stored in the `OBJ_KEY_INDEX`
+     * property of the key. If the key is a string key, the value is retrieved from the `_orgMap` object
+     * using the key itself. If the key is not found, `undefined` is
+     */
+    get(key: K, isObjectKey?: boolean): V | undefined;
+    /**
+     * Time Complexity: O(n), where n is the index.
+     * Space Complexity: O(1)
+     *
+     * The function `getAt` retrieves the key-value pair at a specified index in a linked list.
+     * @param {number} index - The index parameter is a number that represents the position of the
+     * element we want to retrieve from the data structure.
+     * @returns The method `getAt(index: number)` is returning an array containing the key-value pair at
+     * the specified index in the data structure. The key-value pair is represented as a tuple `[K, V]`,
+     * where `K` is the key and `V` is the value.
+     */
+    getAt(index: number): [K, V];
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function `getIterator` returns a new instance of `HashMapIterator` based on the provided key
+     * and whether it is an object key or not.
+     * @param {K} key - The `key` parameter is the key used to retrieve the iterator from the HashMap. It
+     * can be of any type, depending on how the HashMap is implemented.
+     * @param {boolean} [isObjectKey] - The `isObjectKey` parameter is an optional boolean parameter that
+     * indicates whether the `key` parameter is an object key. If `isObjectKey` is `true`, it means that
+     * the `key` parameter is an object and needs to be handled differently. If `isObjectKey` is `false`
+     * @returns a new instance of the `HashMapIterator` class.
+     */
+    getIterator(key: K, isObjectKey?: boolean): HashMapIterator<K, V>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `delete` function removes a key-value pair from a map-like data structure.
+     * @param {K} key - The `key` parameter is the key that you want to delete from the data structure.
+     * It can be of any type, but typically it is a string or an object.
+     * @param {boolean} isObjectKey - The `isObjectKey` parameter is a boolean flag that indicates
+     * whether the `key` parameter is an object key or not. If `isObjectKey` is `true`, it means that the
+     * `key` parameter is an object key. If `isObjectKey` is `false`, it means that the
+     * @returns a boolean value. It returns `true` if the deletion was successful, and `false` if the key
+     * was not found.
+     */
+    delete(key: K, isObjectKey?: boolean): boolean;
+    /**
+     * Time Complexity: O(n), where n is the index.
+     * Space Complexity: O(1)
+     *
+     * The `deleteAt` function deletes a node at a specified index in a linked list.
+     * @param {number} index - The index parameter represents the position at which the node should be
+     * deleted in the linked list.
+     * @returns The size of the list after deleting the element at the specified index.
+     */
+    deleteAt(index: number): number;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function checks if a data structure is empty by comparing its size to zero.
+     * @returns The method is returning a boolean value indicating whether the size of the object is 0 or
+     * not.
+     */
     isEmpty(): boolean;
-    protected _hash(key: K): number;
     /**
-     * The `resizeTable` function resizes the table used in a hash map by creating a new table with a specified capacity and
-     * rehashing the key-value pairs from the old table into the new table.
-     * @param {number} newCapacity - The newCapacity parameter is the desired capacity for the resized table. It represents
-     * the number of buckets that the new table should have.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `clear` function clears all the elements in a data structure and resets its properties.
+     */
+    clear(): void;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function returns a new iterator object for a HashMap.
+     * @returns A new instance of the HashMapIterator class is being returned.
+     */
+    get begin(): HashMapIterator<K, V>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function returns a new HashMapIterator object with the _sentinel value as both the start and
+     * end values.
+     * @returns A new instance of the HashMapIterator class is being returned.
+     */
+    get end(): HashMapIterator<K, V>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The reverseBegin function returns a new HashMapIterator object that iterates over the elements of
+     * a HashMap in reverse order.
+     * @returns A new instance of the HashMapIterator class is being returned.
+     */
+    get reverseBegin(): HashMapIterator<K, V>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The reverseEnd function returns a new HashMapIterator object that iterates over the elements of a
+     * HashMap in reverse order.
+     * @returns A new instance of the HashMapIterator class is being returned.
+     */
+    get reverseEnd(): HashMapIterator<K, V>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function returns the key-value pair at the front of a data structure.
+     * @returns The front element of the data structure, represented as a tuple with a key (K) and a
+     * value (V).
+     */
+    get front(): [K, V] | undefined;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The function returns the key-value pair at the end of a data structure.
+     * @returns The method is returning an array containing the key-value pair of the tail element in the
+     * data structure.
+     */
+    get back(): [K, V] | undefined;
+    /**
+     * 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): void;
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the HashMap.
+     * Space Complexity: O(1)
+     *
+     * The above function is an iterator that yields key-value pairs from a linked list.
+     */
+    [Symbol.iterator](): Generator<[K, V], void, unknown>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `_deleteNode` function removes a node from a doubly linked list and updates the head and tail
+     * pointers if necessary.
+     * @param node - The `node` parameter is an instance of the `HashMapLinkedNode` class, which
+     * represents a node in a linked list. It contains a key-value pair and references to the previous
+     * and next nodes in the list.
      */
-    protected resizeTable(newCapacity: number): void;
+    protected _deleteNode(node: HashMapLinkedNode<K, V>): void;
 }