doubly-linked-list-typed 2.0.5 → 2.1.1

package/dist/data-structures/priority-queue/min-priority-queue.js

@@ -3,91 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinPriorityQueue = void 0;
 const priority_queue_1 = require("./priority-queue");
 /**
- *
+ * Min-oriented priority queue (min-heap) built on {@link PriorityQueue}.
+ * The queue removes the smallest element first under the provided comparator.
+ * Provide a custom comparator if you store non-primitive objects.
+ * @template E Element type stored in the queue.
+ * @template R Extra record/metadata associated with each element.
+ * @example
  */
 class MinPriorityQueue extends priority_queue_1.PriorityQueue {
     /**
-     * The constructor initializes a PriorityQueue with optional elements and options, including a
-     * comparator function.
-     * @param elements - The `elements` parameter is an iterable object that contains the initial
-     * elements to be added to the priority queue. It is optional and defaults to an empty array if not
-     * provided.
-     * @param options - The `options` parameter is an object that contains additional configuration
-     * options for the priority queue. In this case, it has a property called `comparator,` which is a
-     * function used to compare elements in the priority queue. The `comparator` function takes two
-     * parameters `a` and `b`
+     * Creates a min-priority queue.
+     * @param elements Optional initial elements to insert.
+     * @param options Optional configuration (e.g., `comparator`, `toElementFn`).
+     * @remarks Complexity — Time: O(n log n) when inserting n elements incrementally; Space: O(n).
      */
     constructor(elements = [], options) {
         super(elements, options);
     }
-    /**
-     * The `clone` function returns a new instance of the `MinPriorityQueue` class with the same
-     * comparator and toElementFn as the original instance.
-     * @returns The method is returning a new instance of the `MinPriorityQueue` class with the same
-     * properties as the current instance.
-     */
-    clone() {
-        return new MinPriorityQueue(this, { comparator: this.comparator, toElementFn: this.toElementFn });
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `filter` function creates a new MinPriorityQueue object containing elements that pass a given callback
-     * function.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the heap. It takes three arguments: the current element, the index of the current element, and the
-     * heap itself. The callback function should return a boolean value indicating whether the current
-     * element should be included in the filtered list
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `callback` function. If `thisArg` is
-     * @returns The `filter` method is returning a new `MinPriorityQueue` object that contains the elements that pass
-     * the filter condition specified by the `callback` function.
-     */
-    filter(callback, thisArg) {
-        const filteredPriorityQueue = new MinPriorityQueue([], {
-            toElementFn: this.toElementFn,
-            comparator: this.comparator
-        });
-        let index = 0;
-        for (const current of this) {
-            if (callback.call(thisArg, current, index, this)) {
-                filteredPriorityQueue.add(current);
-            }
-            index++;
-        }
-        return filteredPriorityQueue;
-    }
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function creates a new heap by applying a callback function to each element of the
-     * original heap.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the heap. It takes three arguments: `el` (the current element), `index` (the index of the current
-     * element), and `this` (the heap itself). The callback function should return a value of
-     * @param comparator - The `comparator` parameter is a function that defines the order of the
-     * elements in the heap. It takes two elements `a` and `b` as arguments and returns a negative number
-     * if `a` should be placed before `b`, a positive number if `a` should be placed after
-     * @param [toElementFn] - The `toElementFn` parameter is an optional function that converts the raw
-     * element `RR` to the desired type `T`. It takes a single argument `rawElement` of type `RR` and
-     * returns a value of type `T`. This function is used to transform the elements of the original
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
-     * specify the value of `this` within the callback function. It is used to set the context or scope
-     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
-     * value of
-     * @returns a new instance of the `MinPriorityQueue` class with the mapped elements.
-     */
-    map(callback, comparator, toElementFn, thisArg) {
-        const mappedPriorityQueue = new MinPriorityQueue([], { comparator, toElementFn });
-        let index = 0;
-        for (const el of this) {
-            mappedPriorityQueue.add(callback.call(thisArg, el, index, this));
-            index++;
-        }
-        return mappedPriorityQueue;
-    }
 }
 exports.MinPriorityQueue = MinPriorityQueue;

package/dist/data-structures/priority-queue/priority-queue.d.ts

@@ -5,70 +5,11 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import type { Comparator, ElementCallback, PriorityQueueOptions } from '../../types';
+import type { PriorityQueueOptions } from '../../types';
 import { Heap } from '../heap';
 /**
- * 1. Element Priority: In a PriorityQueue, elements are sorted according to their priority. Each dequeue (element removal) operation removes the element with the highest priority. The priority can be determined based on the natural ordering of the elements or through a provided comparator (Comparator).
- * 2. Heap-Based Implementation: PriorityQueue is typically implemented using a binary heap, allowing both insertion and removal operations to be completed in O(log n) time, where n is the number of elements in the queue.
- * 3. Task Scheduling: In systems where tasks need to be processed based on the urgency of tasks rather than the order of arrival.
- * 4. Dijkstra's Algorithm: In shortest path algorithms for graphs, used to select the next shortest edge to visit.
- * 5. Huffman Coding: Used to select the smallest node combination when constructing a Huffman tree.
- * 6. Kth Largest Element in a Data Stream: Used to maintain a min-heap of size K for quickly finding the Kth largest element in stream data
+ * @example
  */
 export declare class PriorityQueue<E = any, R = any> extends Heap<E, R> {
-    /**
-     * The constructor initializes a priority queue with optional elements and options.
-     * @param elements - The `elements` parameter is an iterable object that contains the initial
-     * elements to be added to the priority queue. It is an optional parameter, and if not provided, the
-     * priority queue will be initialized as empty.
-     * @param [options] - The `options` parameter is an optional object that can be used to customize the
-     * behavior of the priority queue. It can contain the following properties:
-     */
     constructor(elements?: Iterable<E> | Iterable<R>, options?: PriorityQueueOptions<E, R>);
-    /**
-     * The `clone` function returns a new instance of the `PriorityQueue` class with the same comparator
-     * and toElementFn as the original instance.
-     * @returns The method is returning a new instance of the `PriorityQueue` class with the same
-     * elements and properties as the current instance.
-     */
-    clone(): PriorityQueue<E, R>;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `filter` function creates a new PriorityQueue object containing elements that pass a given callback
-     * function.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the heap. It takes three arguments: the current element, the index of the current element, and the
-     * heap itself. The callback function should return a boolean value indicating whether the current
-     * element should be included in the filtered list
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `callback` function. If `thisArg` is
-     * @returns The `filter` method is returning a new `PriorityQueue` object that contains the elements that pass
-     * the filter condition specified by the `callback` function.
-     */
-    filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): PriorityQueue<E, R>;
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function creates a new heap by applying a callback function to each element of the
-     * original heap.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the heap. It takes three arguments: `el` (the current element), `index` (the index of the current
-     * element), and `this` (the heap itself). The callback function should return a value of
-     * @param comparator - The `comparator` parameter is a function that defines the order of the
-     * elements in the heap. It takes two elements `a` and `b` as arguments and returns a negative number
-     * if `a` should be placed before `b`, a positive number if `a` should be placed after
-     * @param [toElementFn] - The `toElementFn` parameter is an optional function that converts the raw
-     * element `RR` to the desired type `T`. It takes a single argument `rawElement` of type `RR` and
-     * returns a value of type `T`. This function is used to transform the elements of the original
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
-     * specify the value of `this` within the callback function. It is used to set the context or scope
-     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
-     * value of
-     * @returns a new instance of the `PriorityQueue` class with the mapped elements.
-     */
-    map<EM, RM>(callback: ElementCallback<E, R, EM>, comparator: Comparator<EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): PriorityQueue<EM, RM>;
 }

package/dist/data-structures/priority-queue/priority-queue.js

@@ -1,95 +1,20 @@
 "use strict";
+/**
+ * data-structure-typed
+ *
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @license MIT License
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PriorityQueue = void 0;
 const heap_1 = require("../heap");
 /**
- * 1. Element Priority: In a PriorityQueue, elements are sorted according to their priority. Each dequeue (element removal) operation removes the element with the highest priority. The priority can be determined based on the natural ordering of the elements or through a provided comparator (Comparator).
- * 2. Heap-Based Implementation: PriorityQueue is typically implemented using a binary heap, allowing both insertion and removal operations to be completed in O(log n) time, where n is the number of elements in the queue.
- * 3. Task Scheduling: In systems where tasks need to be processed based on the urgency of tasks rather than the order of arrival.
- * 4. Dijkstra's Algorithm: In shortest path algorithms for graphs, used to select the next shortest edge to visit.
- * 5. Huffman Coding: Used to select the smallest node combination when constructing a Huffman tree.
- * 6. Kth Largest Element in a Data Stream: Used to maintain a min-heap of size K for quickly finding the Kth largest element in stream data
+ * @example
  */
 class PriorityQueue extends heap_1.Heap {
-    /**
-     * The constructor initializes a priority queue with optional elements and options.
-     * @param elements - The `elements` parameter is an iterable object that contains the initial
-     * elements to be added to the priority queue. It is an optional parameter, and if not provided, the
-     * priority queue will be initialized as empty.
-     * @param [options] - The `options` parameter is an optional object that can be used to customize the
-     * behavior of the priority queue. It can contain the following properties:
-     */
     constructor(elements = [], options) {
         super(elements, options);
     }
-    /**
-     * The `clone` function returns a new instance of the `PriorityQueue` class with the same comparator
-     * and toElementFn as the original instance.
-     * @returns The method is returning a new instance of the `PriorityQueue` class with the same
-     * elements and properties as the current instance.
-     */
-    clone() {
-        return new PriorityQueue(this, { comparator: this.comparator, toElementFn: this.toElementFn });
-    }
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
-     *
-     * The `filter` function creates a new PriorityQueue object containing elements that pass a given callback
-     * function.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the heap. It takes three arguments: the current element, the index of the current element, and the
-     * heap itself. The callback function should return a boolean value indicating whether the current
-     * element should be included in the filtered list
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-     * to be used as `this` when executing the `callback` function. If `thisArg` is provided, it will be
-     * passed as the `this` value to the `callback` function. If `thisArg` is
-     * @returns The `filter` method is returning a new `PriorityQueue` object that contains the elements that pass
-     * the filter condition specified by the `callback` function.
-     */
-    filter(callback, thisArg) {
-        const filteredPriorityQueue = new PriorityQueue([], {
-            toElementFn: this.toElementFn,
-            comparator: this.comparator
-        });
-        let index = 0;
-        for (const current of this) {
-            if (callback.call(thisArg, current, index, this)) {
-                filteredPriorityQueue.add(current);
-            }
-            index++;
-        }
-        return filteredPriorityQueue;
-    }
-    /**
-     * Time Complexity: O(n log n)
-     * Space Complexity: O(n)
-     *
-     * The `map` function creates a new heap by applying a callback function to each element of the
-     * original heap.
-     * @param callback - The `callback` parameter is a function that will be called for each element in
-     * the heap. It takes three arguments: `el` (the current element), `index` (the index of the current
-     * element), and `this` (the heap itself). The callback function should return a value of
-     * @param comparator - The `comparator` parameter is a function that defines the order of the
-     * elements in the heap. It takes two elements `a` and `b` as arguments and returns a negative number
-     * if `a` should be placed before `b`, a positive number if `a` should be placed after
-     * @param [toElementFn] - The `toElementFn` parameter is an optional function that converts the raw
-     * element `RR` to the desired type `T`. It takes a single argument `rawElement` of type `RR` and
-     * returns a value of type `T`. This function is used to transform the elements of the original
-     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
-     * specify the value of `this` within the callback function. It is used to set the context or scope
-     * in which the callback function will be executed. If `thisArg` is provided, it will be used as the
-     * value of
-     * @returns a new instance of the `PriorityQueue` class with the mapped elements.
-     */
-    map(callback, comparator, toElementFn, thisArg) {
-        const mappedPriorityQueue = new PriorityQueue([], { comparator, toElementFn });
-        let index = 0;
-        for (const el of this) {
-            mappedPriorityQueue.add(callback.call(thisArg, el, index, this));
-            index++;
-        }
-        return mappedPriorityQueue;
-    }
 }
 exports.PriorityQueue = PriorityQueue;