data-structure-typed 1.33.0 → 1.33.2

package/lib/data-structures/hash/hash-table.js

@@ -1,2 +1,138 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export class HashNode {
+    constructor(key, val) {
+        this.key = key;
+        this.val = val;
+        this.next = null;
+    }
+}
 export class HashTable {
+    get buckets() {
+        return this._buckets;
+    }
+    set buckets(value) {
+        this._buckets = value;
+    }
+    get size() {
+        return this._size;
+    }
+    set size(value) {
+        this._size = value;
+    }
+    get capacity() {
+        return this._capacity;
+    }
+    set capacity(value) {
+        this._capacity = value;
+    }
+    /**
+     * The constructor initializes the capacity, size, and buckets of an object.
+     * @param [capacity=1000] - The `capacity` parameter represents the maximum number of elements that the data structure
+     * can hold. It is an optional parameter with a default value of 1000.
+     */
+    constructor(capacity = 1000) {
+        this._capacity = capacity;
+        this._size = 0;
+        this._buckets = new Array(this.capacity).fill(null);
+    }
+    /**
+     * The hash function takes a key, converts it to a string, calculates the sum of the ASCII values of its characters, and
+     * returns the remainder when divided by the capacity of the data structure.
+     * @param {K} key - The `key` parameter represents the key that needs to be hashed. It is of type `K`, which means it can
+     * be any data type that can be converted to a string.
+     * @returns The hash value of the key modulo the capacity of the data structure.
+     */
+    hash(key) {
+        const keyString = String(key);
+        let hash = 0;
+        for (let i = 0; i < keyString.length; i++) {
+            hash += keyString.charCodeAt(i);
+        }
+        return hash % this.capacity;
+    }
+    /**
+     * The put function adds a key-value pair to a hash table, handling collisions by chaining.
+     * @param {K} key - The key parameter represents the key of the key-value pair that you want to insert into the hash
+     * table. It is of type K, which can be any data type that can be used as a key, such as a string, number, or object.
+     * @param {V} val - The `val` parameter represents the value associated with the key in the hash table.
+     * @returns Nothing is being returned. The return type of the function is void, which means it does not return any value.
+     */
+    put(key, val) {
+        const index = this.hash(key);
+        const newNode = new HashNode(key, val);
+        if (!this.buckets[index]) {
+            this.buckets[index] = newNode;
+        }
+        else {
+            // Handle collision by chaining
+            let currentNode = this.buckets[index];
+            while (currentNode.next) {
+                if (currentNode.key === key) {
+                    // Update the val if the key already exists
+                    currentNode.val = val;
+                    return;
+                }
+                currentNode = currentNode.next;
+            }
+            if (currentNode.key === key) {
+                // Update the val if the key already exists (last node)
+                currentNode.val = val;
+            }
+            else {
+                // Add the new node to the end of the chain
+                currentNode.next = newNode;
+            }
+        }
+        this.size++;
+    }
+    /**
+     * The `get` function retrieves the value associated with a given key from a hash table.
+     * @param {K} key - The parameter "key" represents the key of the element that we want to retrieve from the data
+     * structure.
+     * @returns The method is returning the value associated with the given key if it exists in the hash table. If the key is
+     * not found, it returns `undefined`.
+     */
+    get(key) {
+        const index = this.hash(key);
+        let currentNode = this.buckets[index];
+        while (currentNode) {
+            if (currentNode.key === key) {
+                return currentNode.val;
+            }
+            currentNode = currentNode.next;
+        }
+        return undefined; // Key not found
+    }
+    /**
+     * The `remove` function removes a key-value pair from a hash table.
+     * @param {K} key - The `key` parameter represents the key of the key-value pair that needs to be removed from the hash
+     * table.
+     * @returns Nothing is being returned. The `remove` method has a return type of `void`, which means it does not return
+     * any value.
+     */
+    remove(key) {
+        const index = this.hash(key);
+        let currentNode = this.buckets[index];
+        let prevNode = null;
+        while (currentNode) {
+            if (currentNode.key === key) {
+                if (prevNode) {
+                    prevNode.next = currentNode.next;
+                }
+                else {
+                    this.buckets[index] = currentNode.next;
+                }
+                this.size--;
+                return;
+            }
+            prevNode = currentNode;
+            currentNode = currentNode.next;
+        }
+    }
 }

package/lib/data-structures/heap/heap.d.ts

@@ -7,33 +7,33 @@
  */
 import { PriorityQueue } from '../priority-queue';
 import type { HeapOptions } from '../../types';
-export declare class HeapItem<T = number> {
+export declare class HeapItem<V = any> {
     /**
      * The constructor function initializes an instance of a class with a priority and a value.
      * @param {number} priority - The `priority` parameter is a number that represents the priority of the value. It is
      * optional and has a default value of `NaN`.
-     * @param {T | null} [val=null] - The `val` parameter is of type `T | null`, which means it can accept a value of type
-     * `T` or `null`.
+     * @param {V | null} [val=null] - The `val` parameter is of type `V | null`, which means it can accept a value of type
+     * `V` or `null`.
      */
-    constructor(priority?: number, val?: T | null);
+    constructor(priority?: number, val?: V | null);
     private _priority;
     get priority(): number;
     set priority(value: number);
     private _val;
-    get val(): T | null;
-    set val(value: T | null);
+    get val(): V | null;
+    set val(value: V | null);
 }
-export declare abstract class Heap<T = number> {
+export declare abstract class Heap<V = number> {
     /**
      * The function is a constructor for a class that initializes a priority callback function based on the
      * options provided.
      * @param [options] - An optional object that contains configuration options for the Heap.
      */
-    protected constructor(options?: HeapOptions<T>);
-    protected abstract _pq: PriorityQueue<HeapItem<T>>;
-    get pq(): PriorityQueue<HeapItem<T>>;
-    protected _priorityExtractor: (val: T) => number;
-    get priorityExtractor(): (val: T) => number;
+    protected constructor(options?: HeapOptions<V>);
+    protected abstract _pq: PriorityQueue<HeapItem<V>>;
+    get pq(): PriorityQueue<HeapItem<V>>;
+    protected _priorityExtractor: (val: V) => number;
+    get priorityExtractor(): (val: V) => number;
     /**
      * The function returns the size of a priority queue.
      * @returns The size of the priority queue.
@@ -44,15 +44,15 @@ export declare abstract class Heap<T = number> {
      * @returns {boolean} A boolean value indicating whether the size of the priority queue is less than 1.
      */
     isEmpty(): boolean;
-    peek(isItem?: undefined): T | undefined;
-    peek(isItem: false): T | undefined;
-    peek(isItem: true): HeapItem<T> | null;
-    peekLast(isItem?: undefined): T | undefined;
-    peekLast(isItem: false): T | undefined;
-    peekLast(isItem: true): HeapItem<T> | null;
+    peek(isItem?: undefined): V | undefined;
+    peek(isItem: false): V | undefined;
+    peek(isItem: true): HeapItem<V> | null;
+    peekLast(isItem?: undefined): V | undefined;
+    peekLast(isItem: false): V | undefined;
+    peekLast(isItem: true): HeapItem<V> | null;
     /**
      * The `add` function adds an val to a priority queue with an optional priority value.
-     * @param {T} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
+     * @param {V} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
      * type.
      * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
      * val being added to the heap. If the `val` parameter is a number, then the `priority` parameter is set to
@@ -60,22 +60,22 @@ export declare abstract class Heap<T = number> {
      * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    add(priority: number, val?: T): Heap<T>;
-    poll(isItem?: undefined): T | undefined;
-    poll(isItem: false): T | undefined;
-    poll(isItem: true): HeapItem<T> | null;
+    add(priority: number, val?: V): Heap<V>;
+    poll(isItem?: undefined): V | undefined;
+    poll(isItem: false): V | undefined;
+    poll(isItem: true): HeapItem<V> | null;
     /**
      * The function checks if a given node or value exists in the priority queue.
-     * @param {T | HeapItem<T>} node - The parameter `node` can be of type `T` or `HeapItem<T>`.
+     * @param {V | HeapItem<V>} node - The parameter `node` can be of type `V` or `HeapItem<V>`.
      * @returns a boolean value.
      */
-    has(node: T | HeapItem<T>): boolean;
-    toArray(isItem?: undefined): (T | undefined)[];
-    toArray(isItem: false): (T | undefined)[];
-    toArray(isItem: true): (HeapItem<T> | null)[];
-    sort(isItem?: undefined): (T | undefined)[];
-    sort(isItem: false): (T | undefined)[];
-    sort(isItem: true): (HeapItem<T> | null)[];
+    has(node: V | HeapItem<V>): boolean;
+    toArray(isItem?: undefined): (V | undefined)[];
+    toArray(isItem: false): (V | undefined)[];
+    toArray(isItem: true): (HeapItem<V> | null)[];
+    sort(isItem?: undefined): (V | undefined)[];
+    sort(isItem: false): (V | undefined)[];
+    sort(isItem: true): (HeapItem<V> | null)[];
     /**
      * The clear function clears the priority queue.
      */

package/lib/data-structures/heap/heap.js

@@ -3,8 +3,8 @@ export class HeapItem {
      * The constructor function initializes an instance of a class with a priority and a value.
      * @param {number} priority - The `priority` parameter is a number that represents the priority of the value. It is
      * optional and has a default value of `NaN`.
-     * @param {T | null} [val=null] - The `val` parameter is of type `T | null`, which means it can accept a value of type
-     * `T` or `null`.
+     * @param {V | null} [val=null] - The `val` parameter is of type `V | null`, which means it can accept a value of type
+     * `V` or `null`.
      */
     constructor(priority = Number.MAX_SAFE_INTEGER, val = null) {
         this._val = val;
@@ -63,7 +63,7 @@ export class Heap {
     }
     /**
      * The `peek` function returns the top item in the priority queue without removing it.
-     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an val with the highest priority in the queue
+     * @returns The `peek()` method is returning either a `HeapItem<V>` object or `null`.Returns an val with the highest priority in the queue
      */
     peek(isItem) {
         isItem = isItem !== null && isItem !== void 0 ? isItem : false;
@@ -72,7 +72,7 @@ export class Heap {
     }
     /**
      * The `peekLast` function returns the last item in the heap.
-     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an val with the lowest priority in the queue
+     * @returns The method `peekLast()` returns either a `HeapItem<V>` object or `null`.Returns an val with the lowest priority in the queue
      */
     peekLast(isItem) {
         isItem = isItem !== null && isItem !== void 0 ? isItem : false;
@@ -81,7 +81,7 @@ export class Heap {
     }
     /**
      * The `add` function adds an val to a priority queue with an optional priority value.
-     * @param {T} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
+     * @param {V} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
      * type.
      * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
      * val being added to the heap. If the `val` parameter is a number, then the `priority` parameter is set to
@@ -96,7 +96,7 @@ export class Heap {
     }
     /**
      * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an val with the highest priority in the queue
-     * @returns either a HeapItem<T> object or null.
+     * @returns either a HeapItem<V> object or null.
      */
     poll(isItem) {
         isItem = isItem !== null && isItem !== void 0 ? isItem : false;
@@ -108,7 +108,7 @@ export class Heap {
     }
     /**
      * The function checks if a given node or value exists in the priority queue.
-     * @param {T | HeapItem<T>} node - The parameter `node` can be of type `T` or `HeapItem<T>`.
+     * @param {V | HeapItem<V>} node - The parameter `node` can be of type `V` or `HeapItem<V>`.
      * @returns a boolean value.
      */
     has(node) {
@@ -122,8 +122,8 @@ export class Heap {
         }
     }
     /**
-     * The `toArray` function returns an array of `HeapItem<T>` objects.
-     * @returns An array of HeapItem<T> objects.Returns a sorted list of vals
+     * The `toArray` function returns an array of `HeapItem<V>` objects.
+     * @returns An array of HeapItem<V> objects.Returns a sorted list of vals
      */
     toArray(isItem) {
         isItem = isItem !== null && isItem !== void 0 ? isItem : false;
@@ -134,9 +134,9 @@ export class Heap {
      * The function sorts the elements in the priority queue and returns either the sorted items or their values depending
      * on the value of the isItem parameter.
      * @param {boolean} [isItem] - The `isItem` parameter is a boolean flag that indicates whether the sorted result should
-     * be an array of `HeapItem<T>` objects or an array of the values (`T`) of those objects. If `isItem` is `true`, the
+     * be an array of `HeapItem<V>` objects or an array of the values (`V`) of those objects. If `isItem` is `true`, the
      * sorted result will be an array of `HeapItem
-     * @returns an array of either `HeapItem<T>`, `null`, `T`, or `undefined` values.
+     * @returns an array of either `HeapItem<V>`, `null`, `V`, or `undefined` values.
      */
     sort(isItem) {
         isItem = isItem !== null && isItem !== void 0 ? isItem : false;

package/lib/data-structures/heap/max-heap.d.ts

@@ -12,12 +12,12 @@ import type { HeapOptions } from '../../types';
  * @class MaxHeap
  * @extends Heap
  */
-export declare class MaxHeap<T = number> extends Heap<T> {
-    protected _pq: PriorityQueue<HeapItem<T>>;
+export declare class MaxHeap<V = any> extends Heap<V> {
+    protected _pq: PriorityQueue<HeapItem<V>>;
     /**
      * The constructor initializes a PriorityQueue with a custom comparator function.
      * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
-     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     * type `HeapOptions<V>`, which is a generic type that represents the options for the heap.
      */
-    constructor(options?: HeapOptions<T>);
+    constructor(options?: HeapOptions<V>);
 }

package/lib/data-structures/heap/max-heap.js

@@ -15,7 +15,7 @@ export class MaxHeap extends Heap {
     /**
      * The constructor initializes a PriorityQueue with a custom comparator function.
      * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
-     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     * type `HeapOptions<V>`, which is a generic type that represents the options for the heap.
      */
     constructor(options) {
         super(options);

package/lib/data-structures/heap/min-heap.d.ts

@@ -12,13 +12,13 @@ import type { HeapOptions } from '../../types';
  * @class MinHeap
  * @extends Heap
  */
-export declare class MinHeap<T = number> extends Heap<T> {
-    protected _pq: PriorityQueue<HeapItem<T>>;
+export declare class MinHeap<V = any> extends Heap<V> {
+    protected _pq: PriorityQueue<HeapItem<V>>;
     /**
      * The constructor initializes a PriorityQueue with a comparator function that compares the priority of two HeapItem
      * objects.
      * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
-     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     * type `HeapOptions<V>`, which is a generic type that represents the options for the heap.
      */
-    constructor(options?: HeapOptions<T>);
+    constructor(options?: HeapOptions<V>);
 }

package/lib/data-structures/heap/min-heap.js

@@ -16,7 +16,7 @@ export class MinHeap extends Heap {
      * The constructor initializes a PriorityQueue with a comparator function that compares the priority of two HeapItem
      * objects.
      * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
-     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     * type `HeapOptions<V>`, which is a generic type that represents the options for the heap.
      */
     constructor(options) {
         super(options);