queue-typed 1.45.3 → 1.46.2

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

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { HashMapLinkedNode, HashMapOptions, IterateDirection } from '../../types';
+import { HashMapLinkedNode, IterableWithSizeOrLength, 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.
@@ -45,6 +45,7 @@ export declare class HashMapIterator<K, V> {
     isAccessible(): boolean;
     prev(): this;
     next(): this;
+    clone(): HashMapIterator<K, V>;
 }
 export declare class HashMap<K = any, V = any> {
     readonly OBJ_KEY_INDEX: symbol;
@@ -55,11 +56,11 @@ export declare class HashMap<K = any, V = any> {
     protected readonly _sentinel: HashMapLinkedNode<K, V>;
     /**
      * 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,
+     * @param {Iterable<[K, V]>} elements - 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]>);
+    constructor(elements?: IterableWithSizeOrLength<[K, V]>);
     protected _size: number;
     get size(): number;
     /**
@@ -105,7 +106,7 @@ export declare class HashMap<K = any, V = any> {
      * @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;
+    get first(): [K, V] | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -114,7 +115,7 @@ export declare class HashMap<K = any, V = any> {
      * @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;
+    get last(): [K, V] | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)

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

@@ -109,16 +109,19 @@ class HashMapIterator {
     next() {
         return this;
     }
+    clone() {
+        return new HashMapIterator(this._node, this._sentinel, this.hashMap, this.iterateDirection);
+    }
 }
 exports.HashMapIterator = HashMapIterator;
 class HashMap {
     /**
      * 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,
+     * @param {Iterable<[K, V]>} elements - 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 = []) {
+    constructor(elements = []) {
         this.OBJ_KEY_INDEX = Symbol('OBJ_KEY_INDEX');
         this._nodes = [];
         this._orgMap = {};
@@ -126,9 +129,9 @@ class HashMap {
         Object.setPrototypeOf(this._orgMap, null);
         this._sentinel = {};
         this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
-        hashMap.forEach(el => {
+        for (const el of elements) {
             this.set(el[0], el[1]);
-        });
+        }
     }
     get size() {
         return this._size;
@@ -184,7 +187,7 @@ class HashMap {
      * @returns The front element of the data structure, represented as a tuple with a key (K) and a
      * value (V).
      */
-    get front() {
+    get first() {
         if (this._size === 0)
             return;
         return [this._head.key, this._head.value];
@@ -197,7 +200,7 @@ class HashMap {
      * @returns The method is returning an array containing the key-value pair of the tail element in the
      * data structure.
      */
-    get back() {
+    get last() {
         if (this._size === 0)
             return;
         return [this._tail.key, this._tail.value];

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

@@ -8,10 +8,10 @@ import type { Comparator, DFSOrderPattern } from '../../types';
 export declare class Heap<E = any> {
     constructor(options: {
         comparator: Comparator<E>;
-        nodes?: E[];
+        elements?: E[];
     });
-    protected _nodes: E[];
-    get nodes(): E[];
+    protected _elements: E[];
+    get elements(): E[];
     protected _comparator: Comparator<E>;
     get comparator(): Comparator<E>;
     /**
@@ -24,20 +24,20 @@ export declare class Heap<E = any> {
      */
     get leaf(): E | undefined;
     /**
-     * Static method that creates a binary heap from an array of nodes and a comparison function.
+     * Static method that creates a binary heap from an array of elements and a comparison function.
      * @returns A new Heap instance.
      * @param options
      */
     static heapify<E>(options: {
-        nodes: E[];
+        elements: E[];
         comparator: Comparator<E>;
     }): Heap<E>;
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      *
      * Insert an element into the heap and maintain the heap properties.
@@ -45,11 +45,11 @@ export declare class Heap<E = any> {
      */
     add(element: E): Heap<E>;
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      *
      * Insert an element into the heap and maintain the heap properties.
@@ -57,11 +57,11 @@ export declare class Heap<E = any> {
      */
     push(element: E): Heap<E>;
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -69,11 +69,11 @@ export declare class Heap<E = any> {
      */
     poll(): E | undefined;
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -91,27 +91,27 @@ export declare class Heap<E = any> {
      */
     isEmpty(): boolean;
     /**
-     * Reset the nodes of the heap. Make the nodes empty.
+     * Reset the elements of the heap. Make the elements empty.
      */
     clear(): void;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the nodes array.
+     * Time Complexity: O(n), where n is the number of elements in the elements array.
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the number of elements in the nodes array.
+     * Time Complexity: O(n), where n is the number of elements in the elements array.
      * Space Complexity: O(n)
      *
-     * Clear and add nodes of the heap
-     * @param nodes
+     * Clear and add elements of the heap
+     * @param elements
      */
-    refill(nodes: E[]): void;
+    refill(elements: E[]): void;
     /**
-     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * Time Complexity: O(n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * Time Complexity: O(n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      *
      * Use a comparison function to check whether a binary heap contains a specific element.
@@ -120,11 +120,27 @@ export declare class Heap<E = any> {
      */
     has(element: E): boolean;
     /**
-     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * Time Complexity:  O(n). The worst-case  O(n), where n is the number of elements in the heap. This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity:  O(n). The worst-case  O(n), where n is the number of elements in the heap. This is because, in the worst case, the element to be deleted is located at the end of the heap (not the root), and after deletion, we may need to reorganize the elements by performing a sinkDown operation.
+     * Space Complexity: O(1)
+     *
+     * The `delete` function removes an element from an array-like data structure, maintaining the order
+     * and structure of the remaining elements.
+     * @param {E} element - The `element` parameter represents the element that you want to delete from
+     * the array `this.elements`.
+     * @returns The `delete` function is returning a boolean value. It returns `true` if the element was
+     * successfully deleted from the array, and `false` if the element was not found in the array.
+     */
+    delete(element: E): boolean;
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the heap.
      * Space Complexity: O(h), where h is the height of the heap.
      */
     /**
-     * Time Complexity: O(n), where n is the number of nodes in the heap.
+     * Time Complexity: O(n), where n is the number of elements in the heap.
      * Space Complexity: O(h), where h is the height of the heap.
      *
      * Depth-first search (DFS) method, different traversal orders can be selected。
@@ -144,11 +160,6 @@ export declare class Heap<E = any> {
      * @returns An array containing the elements of the heap.
      */
     toArray(): E[];
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    getNodes(): E[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -178,13 +189,12 @@ export declare class Heap<E = any> {
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n)
+     * Time Complexity: O(n)
      * Space Complexity: O(1)
      *
-     * Float operation to maintain heap properties after adding an element.
-     * @param index - The index of the newly added element.
+     * Fix the entire heap to maintain heap properties.
      */
-    protected bubbleUp(index: number): void;
+    fix(): void;
     /**
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
@@ -193,21 +203,23 @@ export declare class Heap<E = any> {
      * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * Sinking operation to maintain heap properties after removing the top element.
-     * @param index - The index from which to start sinking.
+     * Float operation to maintain heap properties after adding an element.
+     * @param index - The index of the newly added element.
      */
-    protected sinkDown(index: number): void;
+    protected _bubbleUp(index: number): void;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n)
+     * Time Complexity: O(log n)
      * Space Complexity: O(1)
      *
-     * Fix the entire heap to maintain heap properties.
+     * Sinking operation to maintain heap properties after removing the top element.
+     * @param index - The index from which to start sinking.
+     * @param halfLength
      */
-    protected fix(): void;
+    protected _sinkDown(index: number, halfLength: number): void;
 }
 export declare class FibonacciHeapNode<E> {
     element: E;
@@ -274,17 +286,17 @@ export declare class FibonacciHeap<E> {
      */
     peek(): E | undefined;
     /**
-     * Time Complexity: O(n), where n is the number of nodes in the linked list.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(n), where n is the number of nodes in the linked list.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      *
      * 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.
+     * @returns FibonacciHeapNode<E>[] - An array containing the elements of the linked list.
      */
     consumeLinkedList(head?: FibonacciHeapNode<E>): FibonacciHeapNode<E>[];
     /**
@@ -296,11 +308,11 @@ export declare class FibonacciHeap<E> {
      */
     mergeWithChild(parent: FibonacciHeapNode<E>, node: FibonacciHeapNode<E>): void;
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -308,11 +320,11 @@ export declare class FibonacciHeap<E> {
      */
     poll(): E | undefined;
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(log n), where n is the number of elements in the heap.
      * Space Complexity: O(1)
      *
      * Remove and return the top element (smallest or largest element) from the heap.
@@ -384,11 +396,11 @@ export declare class FibonacciHeap<E> {
      */
     protected link(y: FibonacciHeapNode<E>, x: FibonacciHeapNode<E>): void;
     /**
-     * Time Complexity: O(n log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(n log n), where n is the number of elements in the heap.
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n log n), where n is the number of nodes in the heap.
+     * Time Complexity: O(n log n), where n is the number of elements in the heap.
      * Space Complexity: O(n)
      *
      * Remove and return the top element (smallest or largest element) from the heap.