data-structure-typed 1.36.7 → 1.36.9

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

@@ -48,7 +48,7 @@ export declare class HashMap<K, V> {
     private resizeTable;
     set(key: K, value: V): void;
     get(key: K): V | undefined;
-    remove(key: K): void;
+    delete(key: K): void;
     entries(): IterableIterator<[K, V]>;
     [Symbol.iterator](): IterableIterator<[K, V]>;
     clear(): void;

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

@@ -127,7 +127,7 @@ export class HashMap {
         }
         return undefined;
     }
-    remove(key) {
+    delete(key) {
         const index = this._hash(key);
         if (!this.table[index]) {
             return;

package/lib/data-structures/hash/hash-table.d.ts

@@ -90,13 +90,13 @@ export declare class HashTable<K, V> {
      */
     get(key: K): V | undefined;
     /**
-     * The remove function removes a key-value pair from a hash table.
+     * 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 `remove` method has a return type of `void`, which means it does not return
+     * @returns Nothing is being returned. The `delete` method has a return type of `void`, which means it does not return
      * any value.
      */
-    remove(key: K): void;
+    delete(key: K): void;
     /**
      * 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.

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

@@ -178,13 +178,13 @@ export class HashTable {
         return undefined; // Key not found
     }
     /**
-     * The remove function removes a key-value pair from a hash table.
+     * 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 `remove` method has a return type of `void`, which means it does not return
+     * @returns Nothing is being returned. The `delete` method has a return type of `void`, which means it does not return
      * any value.
      */
-    remove(key) {
+    delete(key) {
         const index = this._hash(key);
         let currentNode = this._buckets[index];
         let prevNode = null;

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

@@ -8,18 +8,28 @@ import type { Comparator } from '../../types';
 import { DFSOrderPattern } from '../../types';
 export declare class Heap<E> {
     protected nodes: E[];
-    private readonly comparator;
+    protected readonly comparator: Comparator<E>;
     constructor(comparator: Comparator<E>);
     /**
      * Insert an element into the heap and maintain the heap properties.
-     * @param value - The element to be inserted.
+     * @param element - The element to be inserted.
      */
-    add(value: E): Heap<E>;
+    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 null if the heap is empty.
+     * @returns The top element or undefined if the heap is empty.
      */
-    poll(): E | null;
+    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;
     /**
      * Float operation to maintain heap properties after adding an element.
      * @param index - The index of the newly added element.
@@ -36,18 +46,18 @@ export declare class Heap<E> {
     protected fix(): void;
     /**
      * Peek at the top element of the heap without removing it.
-     * @returns The top element or null if the heap is empty.
+     * @returns The top element or undefined if the heap is empty.
      */
-    peek(): E | null;
+    peek(): E | undefined;
     /**
      * 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 null if the heap is empty.
+     * @returns The last element or undefined if the heap is empty.
      */
-    get leaf(): E | null;
+    get leaf(): E | undefined;
     /**
      * Check if the heap is empty.
      * @returns True if the heap is empty, otherwise false.
@@ -64,10 +74,10 @@ export declare class Heap<E> {
     refill(nodes: E[]): void;
     /**
      * Use a comparison function to check whether a binary heap contains a specific element.
-     * @param value - the element to check.
+     * @param element - the element to check.
      * @returns Returns true if the specified element is contained; otherwise, returns false.
      */
-    has(value: E): boolean;
+    has(element: E): boolean;
     /**
      * Depth-first search (DFS) method, different traversal orders can be selected。
      * @param order - Traversal order parameter: 'in' (in-order), 'pre' (pre-order) or 'post' (post-order).
@@ -98,3 +108,118 @@ export declare class Heap<E> {
      */
     static heapify<E>(nodes: E[], comparator: Comparator<E>): Heap<E>;
 }
+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>;
+    protected min?: FibonacciHeapNode<E>;
+    size: number;
+    protected readonly comparator: Comparator<E>;
+    constructor(comparator?: Comparator<E>);
+    /**
+     * Default comparator function used by the heap.
+     * @param {E} a
+     * @param {E} b
+     * @protected
+     */
+    protected defaultComparator(a: E, b: E): number;
+    /**
+     * 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;
+    /**
+     * 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(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 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 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.
+     * @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;
+    /**
+     * 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;
+}

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

@@ -11,20 +11,27 @@ export class Heap {
     }
     /**
      * Insert an element into the heap and maintain the heap properties.
-     * @param value - The element to be inserted.
+     * @param element - The element to be inserted.
      */
-    add(value) {
-        this.nodes.push(value);
+    add(element) {
+        return this.push(element);
+    }
+    /**
+     * Insert an element into the heap and maintain the heap properties.
+     * @param element - The element to be inserted.
+     */
+    push(element) {
+        this.nodes.push(element);
         this.bubbleUp(this.nodes.length - 1);
         return this;
     }
     /**
      * Remove and return the top element (smallest or largest element) from the heap.
-     * @returns The top element or null if the heap is empty.
+     * @returns The top element or undefined if the heap is empty.
      */
     poll() {
         if (this.nodes.length === 0) {
-            return null;
+            return undefined;
         }
         if (this.nodes.length === 1) {
             return this.nodes.pop();
@@ -34,6 +41,13 @@ export class Heap {
         this.sinkDown(0);
         return topValue;
     }
+    /**
+     * 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() {
+        return this.poll();
+    }
     /**
      * Float operation to maintain heap properties after adding an element.
      * @param index - The index of the newly added element.
@@ -84,11 +98,11 @@ export class Heap {
     }
     /**
      * Peek at the top element of the heap without removing it.
-     * @returns The top element or null if the heap is empty.
+     * @returns The top element or undefined if the heap is empty.
      */
     peek() {
         if (this.nodes.length === 0) {
-            return null;
+            return undefined;
         }
         return this.nodes[0];
     }
@@ -100,11 +114,11 @@ export class Heap {
     }
     /**
      * Get the last element in the heap, which is not necessarily a leaf node.
-     * @returns The last element or null if the heap is empty.
+     * @returns The last element or undefined if the heap is empty.
      */
     get leaf() {
         var _a;
-        return (_a = this.nodes[this.size - 1]) !== null && _a !== void 0 ? _a : null;
+        return (_a = this.nodes[this.size - 1]) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
      * Check if the heap is empty.
@@ -129,11 +143,11 @@ export class Heap {
     }
     /**
      * Use a comparison function to check whether a binary heap contains a specific element.
-     * @param value - the element to check.
+     * @param element - the element to check.
      * @returns Returns true if the specified element is contained; otherwise, returns false.
      */
-    has(value) {
-        return this.nodes.includes(value);
+    has(element) {
+        return this.nodes.includes(element);
     }
     /**
      * Depth-first search (DFS) method, different traversal orders can be selected。
@@ -211,3 +225,267 @@ export class Heap {
         return binaryHeap;
     }
 }
+export class FibonacciHeapNode {
+    constructor(element, degree = 0) {
+        this.element = element;
+        this.degree = degree;
+        this.marked = false;
+    }
+}
+export class FibonacciHeap {
+    constructor(comparator) {
+        this.size = 0;
+        this.clear();
+        this.comparator = comparator || this.defaultComparator;
+        if (typeof this.comparator !== 'function') {
+            throw new Error('FibonacciHeap constructor: given comparator should be a function.');
+        }
+    }
+    /**
+     * Default comparator function used by the heap.
+     * @param {E} a
+     * @param {E} b
+     * @protected
+     */
+    defaultComparator(a, b) {
+        if (a < b)
+            return -1;
+        if (a > b)
+            return 1;
+        return 0;
+    }
+    /**
+     * 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() {
+        this.root = undefined;
+        this.min = undefined;
+        this.size = 0;
+    }
+    /**
+     * Create a new node.
+     * @param element
+     * @protected
+     */
+    createNode(element) {
+        return new FibonacciHeapNode(element);
+    }
+    /**
+     * Merge the given node with the root list.
+     * @param node - The node to be merged.
+     */
+    mergeWithRoot(node) {
+        if (!this.root) {
+            this.root = node;
+        }
+        else {
+            node.right = this.root.right;
+            node.left = this.root;
+            this.root.right.left = node;
+            this.root.right = node;
+        }
+    }
+    /**
+     * 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) {
+        return this.push(element);
+    }
+    /**
+     * 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) {
+        const node = this.createNode(element);
+        node.left = node;
+        node.right = node;
+        this.mergeWithRoot(node);
+        if (!this.min || this.comparator(node.element, this.min.element) <= 0) {
+            this.min = node;
+        }
+        this.size++;
+        return this;
+    }
+    /**
+     * 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() {
+        return this.min ? this.min.element : 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) {
+        const nodes = [];
+        if (!head)
+            return nodes;
+        let node = head;
+        let flag = false;
+        while (true) {
+            if (node === head && flag)
+                break;
+            else if (node === head)
+                flag = true;
+            if (node) {
+                nodes.push(node);
+                node = node.right;
+            }
+        }
+        return nodes;
+    }
+    /**
+     * 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
+     */
+    removeFromRoot(node) {
+        if (this.root === node)
+            this.root = node.right;
+        if (node.left)
+            node.left.right = node.right;
+        if (node.right)
+            node.right.left = node.left;
+    }
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @param parent
+     * @param node
+     */
+    mergeWithChild(parent, node) {
+        if (!parent.child) {
+            parent.child = node;
+        }
+        else {
+            node.right = parent.child.right;
+            node.left = parent.child;
+            parent.child.right.left = node;
+            parent.child.right = node;
+        }
+    }
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @param y
+     * @param x
+     * @protected
+     */
+    link(y, x) {
+        this.removeFromRoot(y);
+        y.left = y;
+        y.right = y;
+        this.mergeWithChild(x, y);
+        x.degree++;
+        y.parent = x;
+    }
+    /**
+     * O(log n) time operation.
+     * Remove and return the top element (smallest or largest element) from the heap.
+     * @protected
+     */
+    consolidate() {
+        const A = new Array(this.size);
+        const nodes = this.consumeLinkedList(this.root);
+        let x, y, d, t;
+        for (const node of nodes) {
+            x = node;
+            d = x.degree;
+            while (A[d]) {
+                y = A[d];
+                if (this.comparator(x.element, y.element) > 0) {
+                    t = x;
+                    x = y;
+                    y = t;
+                }
+                this.link(y, x);
+                A[d] = undefined;
+                d++;
+            }
+            A[d] = x;
+        }
+        for (let i = 0; i < this.size; i++) {
+            if (A[i] && this.comparator(A[i].element, this.min.element) <= 0) {
+                this.min = A[i];
+            }
+        }
+    }
+    /**
+     * 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() {
+        return this.pop();
+    }
+    /**
+     * 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() {
+        if (this.size === 0)
+            return undefined;
+        const z = this.min;
+        if (z.child) {
+            const nodes = this.consumeLinkedList(z.child);
+            for (const node of nodes) {
+                this.mergeWithRoot(node);
+                node.parent = undefined;
+            }
+        }
+        this.removeFromRoot(z);
+        if (z === z.right) {
+            this.min = undefined;
+            this.root = undefined;
+        }
+        else {
+            this.min = z.right;
+            this.consolidate();
+        }
+        this.size--;
+        return z.element;
+    }
+    /**
+     * 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) {
+        if (heapToMerge.size === 0) {
+            return; // Nothing to merge
+        }
+        // Merge the root lists of the two heaps
+        if (this.root && heapToMerge.root) {
+            const thisRoot = this.root;
+            const otherRoot = heapToMerge.root;
+            const thisRootRight = thisRoot.right;
+            const otherRootLeft = otherRoot.left;
+            thisRoot.right = otherRoot;
+            otherRoot.left = thisRoot;
+            thisRootRight.left = otherRootLeft;
+            otherRootLeft.right = thisRootRight;
+        }
+        // Update the minimum node
+        if (!this.min || (heapToMerge.min && this.comparator(heapToMerge.min.element, this.min.element) < 0)) {
+            this.min = heapToMerge.min;
+        }
+        // Update the size
+        this.size += heapToMerge.size;
+        // Clear the heap that was merged
+        heapToMerge.clear();
+    }
+}

package/lib/data-structures/linked-list/skip-linked-list.d.ts

@@ -52,10 +52,10 @@ export declare class SkipList<K, V> {
      */
     get(key: K): V | undefined;
     /**
-     * The `remove` function removes a node with a specific key from a Skip List data structure.
+     * The `delete` function removes a node with a specific key from a Skip List data structure.
      * @param {K} key - The key parameter represents the key of the node that needs to be removed from the skip list.
-     * @returns The `remove` method returns a boolean value. It returns `true` if the key was successfully removed from the
+     * @returns The `delete` method returns a boolean value. It returns `true` if the key was successfully removed from the
      * skip list, and `false` if the key was not found in the skip list.
      */
-    remove(key: K): boolean;
+    delete(key: K): boolean;
 }

package/lib/data-structures/linked-list/skip-linked-list.js

@@ -105,12 +105,12 @@ export class SkipList {
         return undefined;
     }
     /**
-     * The `remove` function removes a node with a specific key from a Skip List data structure.
+     * The `delete` function removes a node with a specific key from a Skip List data structure.
      * @param {K} key - The key parameter represents the key of the node that needs to be removed from the skip list.
-     * @returns The `remove` method returns a boolean value. It returns `true` if the key was successfully removed from the
+     * @returns The `delete` method returns a boolean value. It returns `true` if the key was successfully removed from the
      * skip list, and `false` if the key was not found in the skip list.
      */
-    remove(key) {
+    delete(key) {
         const update = new Array(this.maxLevel).fill(this.head);
         let current = this.head;
         for (let i = this.level - 1; i >= 0; i--) {

package/lib/data-structures/queue/deque.d.ts

@@ -150,12 +150,12 @@ export declare class ArrayDeque<E> {
      */
     insert(index: number, value: E): E[];
     /**
-     * The remove function removes an element from an array at a specified index.
+     * The delete function removes an element from an array at a specified index.
      * @param {number} index - The index parameter specifies the position of the element to be removed from the array. It
      * is a number that represents the index of the element to be removed.
      * @returns The method is returning an array containing the removed element.
      */
-    remove(index: number): E[];
+    delete(index: number): E[];
     /**
      * The function checks if an array called "_nodes" is empty.
      * @returns The method `isEmpty()` is returning a boolean value. It returns `true` if the length of the `_nodes` array

package/lib/data-structures/queue/deque.js

@@ -251,12 +251,12 @@ export class ArrayDeque {
         return this._nodes.splice(index, 0, value);
     }
     /**
-     * The remove function removes an element from an array at a specified index.
+     * The delete function removes an element from an array at a specified index.
      * @param {number} index - The index parameter specifies the position of the element to be removed from the array. It
      * is a number that represents the index of the element to be removed.
      * @returns The method is returning an array containing the removed element.
      */
-    remove(index) {
+    delete(index) {
         return this._nodes.splice(index, 1);
     }
     /**

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

@@ -90,7 +90,7 @@ export class Queue {
         this.offset += 1;
         if (this.offset * 2 < this.nodes.length)
             return first;
-        // only remove dequeued elements when reaching half size
+        // only delete dequeued elements when reaching half size
         // to decrease latency of shifting elements.
         this.nodes = this.nodes.slice(this.offset);
         this.offset = 0;

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

@@ -45,10 +45,10 @@ export declare class Trie {
     private _caseProcess;
     /**
      * Remove a word from the Trie structure.
-     * @param{string} word - The word to remove.
+     * @param{string} word - The word to delete.
      * @returns {boolean} True if the word was successfully removed.
      */
-    remove(word: string): boolean;
+    delete(word: string): boolean;
     getHeight(): number;
     /**
      * Check if a given input string has an absolute prefix in the Trie, meaning it's not a complete word.