data-structure-typed 1.36.7 → 1.36.8

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "1.36.7",
+  "version": "1.36.8",
   "description": "Data Structures of Javascript & TypeScript. Binary Tree, BST, Graph, Heap, Priority Queue, Linked List, Queue, Deque, Stack, AVL Tree, Tree Multiset, Trie, Directed Graph, Undirected Graph, Singly Linked List, Doubly Linked List, Max Heap, Max Priority Queue, Min Heap, Min Priority Queue.",
   "main": "dist/index.js",
   "module": "lib/index.js",
@@ -33,7 +33,8 @@
     "check:deps": "dependency-cruiser src",
     "changelog": "auto-changelog",
     "coverage:badge": "istanbul-badges-readme",
-    "ci": "env && npm run lint && npm run build && npm run update:individuals && npm run test && git fetch --tags && npm run changelog"
+    "ci": "env && npm run lint && npm run build && npm run update:individuals && npm run test && git fetch --tags && npm run changelog",
+    "publish:all": "npm run ci && npm publish && sh /scripts/publish_all_subs.sh && sh /scripts/publish_docs.sh"
   },
   "repository": {
     "type": "git",