min-heap-typed 1.37.9 → 1.38.1

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

@@ -0,0 +1,245 @@
+"use strict";
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashTable = exports.HashTableNode = void 0;
+class HashTableNode {
+    constructor(key, val) {
+        this.key = key;
+        this.val = val;
+        this.next = null;
+    }
+}
+exports.HashTableNode = HashTableNode;
+class HashTable {
+    constructor(capacity = HashTable.DEFAULT_CAPACITY, hashFn) {
+        this._hashFn = hashFn || this._defaultHashFn;
+        this._capacity = Math.max(capacity, HashTable.DEFAULT_CAPACITY);
+        this._size = 0;
+        this._buckets = new Array(this._capacity).fill(null);
+    }
+    get capacity() {
+        return this._capacity;
+    }
+    set capacity(value) {
+        this._capacity = value;
+    }
+    get size() {
+        return this._size;
+    }
+    get buckets() {
+        return this._buckets;
+    }
+    set buckets(value) {
+        this._buckets = value;
+    }
+    get hashFn() {
+        return this._hashFn;
+    }
+    set hashFn(value) {
+        this._hashFn = value;
+    }
+    /**
+     * The set function adds a key-value pair to the hash table, handling collisions and resizing if necessary.
+     * @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 is a generic type representing the key's data type.
+     * @param {V} val - The parameter `val` represents the value that you want to associate with the given key in the hash
+     * table.
+     * @returns Nothing is being returned. The return type of the `put` method is `void`, which means it does not return any
+     * value.
+     */
+    set(key, val) {
+        const index = this._hash(key);
+        const newNode = new HashTableNode(key, val);
+        if (!this._buckets[index]) {
+            this._buckets[index] = newNode;
+        }
+        else {
+            // Handle collisions, consider using open addressing, etc.
+            let currentNode = this._buckets[index];
+            while (currentNode) {
+                if (currentNode.key === key) {
+                    // If the key already exists, update the value
+                    currentNode.val = val;
+                    return;
+                }
+                if (!currentNode.next) {
+                    break;
+                }
+                currentNode = currentNode.next;
+            }
+            // Add to the end of the linked list
+            currentNode.next = newNode;
+        }
+        this._size++;
+        // If the load factor is too high, resize the hash table
+        if (this._size / this._capacity >= HashTable.LOAD_FACTOR) {
+            this._expand();
+        }
+    }
+    /**
+     * The `get` function retrieves the value associated with a given key from a hash table.
+     * @param {K} key - The `key` parameter 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 delete 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 `delete` method has a return type of `void`, which means it does not return
+     * any value.
+     */
+    delete(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--;
+                currentNode.next = null; // Release memory
+                return;
+            }
+            prevNode = currentNode;
+            currentNode = currentNode.next;
+        }
+    }
+    /**
+     * The function `_defaultHashFn` calculates the hash value of a given key and returns the remainder when divided by the
+     * capacity of the data structure.
+     * @param {K} key - The `key` parameter is the input value that needs to be hashed. It can be of any type, but in this
+     * code snippet, it is checked whether the key is a string or an object. If it is a string, the `_murmurStringHashFn`
+     * function is used to
+     * @returns the hash value of the key modulo the capacity of the data structure.
+     */
+    _defaultHashFn(key) {
+        // Can be replaced with other hash functions as needed
+        const hashValue = typeof key === 'string' ? this._murmurStringHashFn(key) : this._objectHash(key);
+        return hashValue % this._capacity;
+    }
+    /**
+     * The `_multiplicativeStringHashFn` function calculates a hash value for a given string key using the multiplicative
+     * string hash function.
+     * @param {K} key - The `key` parameter is the input value for which we want to calculate the hash. It can be of any
+     * type, as it is generic (`K`). The function converts the `key` to a string using the `String()` function.
+     * @returns a number, which is the result of the multiplicative string hash function applied to the input key.
+     */
+    _multiplicativeStringHashFn(key) {
+        const keyString = String(key);
+        let hash = 0;
+        for (let i = 0; i < keyString.length; i++) {
+            const charCode = keyString.charCodeAt(i);
+            // Some constants for adjusting the hash function
+            const A = 0.618033988749895;
+            const M = 1 << 30; // 2^30
+            hash = (hash * A + charCode) % M;
+        }
+        return Math.abs(hash); // Take absolute value to ensure non-negative numbers
+    }
+    /**
+     * The function `_murmurStringHashFn` calculates a hash value for a given string key using the MurmurHash algorithm.
+     * @param {K} key - The `key` parameter is the input value for which you want to calculate the hash. It can be of any
+     * type, but it will be converted to a string using the `String()` function before calculating the hash.
+     * @returns a number, which is the hash value calculated for the given key.
+     */
+    _murmurStringHashFn(key) {
+        const keyString = String(key);
+        const seed = 0;
+        let hash = seed;
+        for (let i = 0; i < keyString.length; i++) {
+            const char = keyString.charCodeAt(i);
+            hash = (hash ^ char) * 0x5bd1e995;
+            hash = (hash ^ (hash >>> 15)) * 0x27d4eb2d;
+            hash = hash ^ (hash >>> 15);
+        }
+        return Math.abs(hash);
+    }
+    /**
+     * The _hash function takes a key and returns a number.
+     * @param {K} key - The parameter "key" is of type K, which represents the type of the key that will be hashed.
+     * @returns The hash function is returning a number.
+     */
+    _hash(key) {
+        return this.hashFn(key);
+    }
+    /**
+     * The function calculates a hash value for a given string using the djb2 algorithm.
+     * @param {string} key - The `key` parameter in the `stringHash` function is a string value that represents the input for
+     * which we want to calculate the hash value.
+     * @returns a number, which is the hash value of the input string.
+     */
+    _stringHash(key) {
+        let hash = 0;
+        for (let i = 0; i < key.length; i++) {
+            hash = (hash * 31 + key.charCodeAt(i)) & 0xffffffff;
+        }
+        return hash;
+    }
+    /**
+     * The function `_objectHash` takes a key and returns a hash value, using a custom hash function for objects.
+     * @param {K} key - The parameter "key" is of type "K", which means it can be any type. It could be a string, number,
+     * boolean, object, or any other type of value. The purpose of the objectHash function is to generate a hash value for
+     * the key, which can be used for
+     * @returns a number, which is the hash value of the key.
+     */
+    _objectHash(key) {
+        // If the key is an object, you can write a custom hash function
+        // For example, convert the object's properties to a string and use string hashing
+        // This is just an example; you should write a specific object hash function as needed
+        return this._stringHash(JSON.stringify(key));
+    }
+    /**
+     * The `expand` function increases the capacity of a hash table by creating a new array of buckets with double the
+     * capacity and rehashing all the existing key-value pairs into the new buckets.
+     */
+    _expand() {
+        const newCapacity = this._capacity * 2;
+        const newBuckets = new Array(newCapacity).fill(null);
+        for (const bucket of this._buckets) {
+            let currentNode = bucket;
+            while (currentNode) {
+                const newIndex = this._hash(currentNode.key);
+                const newNode = new HashTableNode(currentNode.key, currentNode.val);
+                if (!newBuckets[newIndex]) {
+                    newBuckets[newIndex] = newNode;
+                }
+                else {
+                    let currentNewNode = newBuckets[newIndex];
+                    while (currentNewNode.next) {
+                        currentNewNode = currentNewNode.next;
+                    }
+                    currentNewNode.next = newNode;
+                }
+                currentNode = currentNode.next;
+            }
+        }
+        this._buckets = newBuckets;
+        this._capacity = newCapacity;
+    }
+}
+exports.HashTable = HashTable;
+HashTable.DEFAULT_CAPACITY = 16;
+HashTable.LOAD_FACTOR = 0.75;

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

@@ -0,0 +1,6 @@
+export * from './hash-table';
+export * from './coordinate-map';
+export * from './coordinate-set';
+export * from './tree-map';
+export * from './tree-set';
+export * from './hash-map';

package/dist/data-structures/hash/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hash-table"), exports);
+__exportStar(require("./coordinate-map"), exports);
+__exportStar(require("./coordinate-set"), exports);
+__exportStar(require("./tree-map"), exports);
+__exportStar(require("./tree-set"), exports);
+__exportStar(require("./hash-map"), exports);

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

@@ -0,0 +1,2 @@
+export declare class TreeMap {
+}

package/dist/data-structures/hash/tree-map.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeMap = void 0;
+class TreeMap {
+}
+exports.TreeMap = TreeMap;

package/dist/data-structures/hash/tree-set.d.ts

@@ -0,0 +1,2 @@
+export declare class TreeSet {
+}

package/dist/data-structures/hash/tree-set.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeSet = void 0;
+class TreeSet {
+}
+exports.TreeSet = TreeSet;

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

@@ -0,0 +1,224 @@
+/**
+ * data-structure-typed
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @license MIT License
+ */
+import type { Comparator, DFSOrderPattern } from '../../types';
+export declare class Heap<E> {
+    protected nodes: E[];
+    protected readonly comparator: Comparator<E>;
+    constructor(comparator: Comparator<E>);
+    /**
+     * Get the size (number of elements) of the heap.
+     */
+    get size(): number;
+    /**
+     * Get the last element in the heap, which is not necessarily a leaf node.
+     * @returns The last element or undefined if the heap is empty.
+     */
+    get leaf(): E | undefined;
+    /**
+     * Static method that creates a binary heap from an array of nodes and a comparison function.
+     * @param nodes
+     * @param comparator - Comparison function.
+     * @returns A new Heap instance.
+     */
+    static heapify<E>(nodes: E[], comparator: Comparator<E>): Heap<E>;
+    /**
+     * Insert an element into the heap and maintain the heap properties.
+     * @param element - The element to be inserted.
+     */
+    add(element: E): Heap<E>;
+    /**
+     * Insert an element into the heap and maintain the heap properties.
+     * @param element - The element to be inserted.
+     */
+    push(element: E): Heap<E>;
+    /**
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @returns The top element or undefined if the heap is empty.
+     */
+    poll(): E | undefined;
+    /**
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @returns The top element or undefined if the heap is empty.
+     */
+    pop(): E | undefined;
+    /**
+     * Peek at the top element of the heap without removing it.
+     * @returns The top element or undefined if the heap is empty.
+     */
+    peek(): E | undefined;
+    /**
+     * Check if the heap is empty.
+     * @returns True if the heap is empty, otherwise false.
+     */
+    isEmpty(): boolean;
+    /**
+     * Reset the nodes of the heap. Make the nodes empty.
+     */
+    clear(): void;
+    /**
+     * Clear and add nodes of the heap
+     * @param nodes
+     */
+    refill(nodes: E[]): void;
+    /**
+     * Use a comparison function to check whether a binary heap contains a specific element.
+     * @param element - the element to check.
+     * @returns Returns true if the specified element is contained; otherwise, returns false.
+     */
+    has(element: E): boolean;
+    /**
+     * Depth-first search (DFS) method, different traversal orders can be selected。
+     * @param order - Traverse order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
+     * @returns An array containing elements traversed in the specified order.
+     */
+    dfs(order: DFSOrderPattern): E[];
+    /**
+     * Convert the heap to an array.
+     * @returns An array containing the elements of the heap.
+     */
+    toArray(): E[];
+    getNodes(): E[];
+    /**
+     * Clone the heap, creating a new heap with the same elements.
+     * @returns A new Heap instance containing the same elements.
+     */
+    clone(): Heap<E>;
+    /**
+     * Sort the elements in the heap and return them as an array.
+     * @returns An array containing the elements sorted in ascending order.
+     */
+    sort(): E[];
+    /**
+     * Float operation to maintain heap properties after adding an element.
+     * @param index - The index of the newly added element.
+     */
+    protected bubbleUp(index: number): void;
+    /**
+     * Sinking operation to maintain heap properties after removing the top element.
+     * @param index - The index from which to start sinking.
+     */
+    protected sinkDown(index: number): void;
+    /**
+     * Fix the entire heap to maintain heap properties.
+     */
+    protected fix(): void;
+}
+export declare class FibonacciHeapNode<E> {
+    element: E;
+    degree: number;
+    left?: FibonacciHeapNode<E>;
+    right?: FibonacciHeapNode<E>;
+    child?: FibonacciHeapNode<E>;
+    parent?: FibonacciHeapNode<E>;
+    marked: boolean;
+    constructor(element: E, degree?: number);
+}
+export declare class FibonacciHeap<E> {
+    root?: FibonacciHeapNode<E>;
+    size: number;
+    protected min?: FibonacciHeapNode<E>;
+    protected readonly comparator: Comparator<E>;
+    constructor(comparator?: Comparator<E>);
+    /**
+     * Get the size (number of elements) of the heap.
+     * @returns {number} The size of the heap.  Returns 0 if the heap is empty. Returns -1 if the heap is invalid.
+     */
+    clear(): void;
+    /**
+     * O(1) time operation.
+     * Insert an element into the heap and maintain the heap properties.
+     * @param element
+     * @returns {FibonacciHeap<E>} FibonacciHeap<E> - The heap itself.
+     */
+    add(element: E): FibonacciHeap<E>;
+    /**
+     * O(1) time operation.
+     * Insert an element into the heap and maintain the heap properties.
+     * @param element
+     * @returns {FibonacciHeap<E>} FibonacciHeap<E> - The heap itself.
+     */
+    push(element: E): FibonacciHeap<E>;
+    /**
+     * O(1) time operation.
+     * Peek at the top element of the heap without removing it.
+     * @returns The top element or undefined if the heap is empty.
+     * @protected
+     */
+    peek(): E | undefined;
+    /**
+     * O(1) time operation.
+     * Get the size (number of elements) of the heap.
+     * @param {FibonacciHeapNode<E>} head - The head of the linked list.
+     * @protected
+     * @returns FibonacciHeapNode<E>[] - An array containing the nodes of the linked list.
+     */
+    consumeLinkedList(head?: FibonacciHeapNode<E>): FibonacciHeapNode<E>[];
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @param parent
+     * @param node
+     */
+    mergeWithChild(parent: FibonacciHeapNode<E>, node: FibonacciHeapNode<E>): void;
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @returns The top element or undefined if the heap is empty.
+     */
+    poll(): E | undefined;
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @returns The top element or undefined if the heap is empty.
+     */
+    pop(): E | undefined;
+    /**
+     * O(log n) time operation.
+     * merge two heaps. The heap that is merged will be cleared. The heap that is merged into will remain.
+     * @param heapToMerge
+     */
+    merge(heapToMerge: FibonacciHeap<E>): void;
+    /**
+     * Default comparator function used by the heap.
+     * @param {E} a
+     * @param {E} b
+     * @protected
+     */
+    protected defaultComparator(a: E, b: E): number;
+    /**
+     * Create a new node.
+     * @param element
+     * @protected
+     */
+    protected createNode(element: E): FibonacciHeapNode<E>;
+    /**
+     * Merge the given node with the root list.
+     * @param node - The node to be merged.
+     */
+    protected mergeWithRoot(node: FibonacciHeapNode<E>): void;
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @param node - The node to be removed.
+     * @protected
+     */
+    protected removeFromRoot(node: FibonacciHeapNode<E>): void;
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @param y
+     * @param x
+     * @protected
+     */
+    protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void;
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @protected
+     */
+    protected consolidate(): void;
+}