data-structure-typed 0.8.18 → 1.12.9

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

@@ -1,15 +1,40 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxPriorityQueue = void 0;
-const priority_queue_1 = require("./priority-queue");
-class MaxPriorityQueue extends priority_queue_1.PriorityQueue {
-    constructor(options) {
-        super({
-            nodes: options.nodes, comparator: (a, b) => {
-                const aKey = a, bKey = b;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+var priority_queue_1 = require("./priority-queue");
+var MaxPriorityQueue = /** @class */ (function (_super) {
+    __extends(MaxPriorityQueue, _super);
+    /**
+     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
+     * @param [options] - An optional object that contains the following properties:
+     */
+    function MaxPriorityQueue(options) {
+        return _super.call(this, {
+            nodes: options === null || options === void 0 ? void 0 : options.nodes, comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {
+                var aKey = a, bKey = b;
                 return bKey - aKey;
             }
-        });
+        }) || this;
     }
-}
+    return MaxPriorityQueue;
+}(priority_queue_1.PriorityQueue));
 exports.MaxPriorityQueue = MaxPriorityQueue;

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

@@ -1,4 +1,13 @@
-import { PriorityQueue, PriorityQueueOptions } from './priority-queue';
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+import { PriorityQueue } from './priority-queue';
+import type { PriorityQueueOptions } from '../types';
 export declare class MinPriorityQueue<T = number> extends PriorityQueue<T> {
-    constructor(options: PriorityQueueOptions<T>);
+    /**
+     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
+     * @param [options] - An optional object that contains the following properties:
+     */
+    constructor(options?: PriorityQueueOptions<T>);
 }

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

@@ -1,15 +1,40 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinPriorityQueue = void 0;
-const priority_queue_1 = require("./priority-queue");
-class MinPriorityQueue extends priority_queue_1.PriorityQueue {
-    constructor(options) {
-        super({
-            nodes: options.nodes, comparator: (a, b) => {
-                const aKey = a, bKey = b;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+var priority_queue_1 = require("./priority-queue");
+var MinPriorityQueue = /** @class */ (function (_super) {
+    __extends(MinPriorityQueue, _super);
+    /**
+     * The constructor initializes a PriorityQueue with optional nodes and a comparator function.
+     * @param [options] - An optional object that contains the following properties:
+     */
+    function MinPriorityQueue(options) {
+        return _super.call(this, {
+            nodes: options === null || options === void 0 ? void 0 : options.nodes, comparator: (options === null || options === void 0 ? void 0 : options.comparator) ? options.comparator : function (a, b) {
+                var aKey = a, bKey = b;
                 return aKey - bKey;
             }
-        });
+        }) || this;
     }
-}
+    return MinPriorityQueue;
+}(priority_queue_1.PriorityQueue));
 exports.MinPriorityQueue = MinPriorityQueue;

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

@@ -1,36 +1,160 @@
-export type PriorityQueueComparator<T> = (a: T, b: T) => number;
-export interface PriorityQueueOptions<T> {
-    nodes?: T[];
-    isFix?: boolean;
-    comparator: PriorityQueueComparator<T>;
-}
-export type PriorityQueueDFSOrderPattern = 'pre' | 'in' | 'post';
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
+import type { PriorityQueueComparator, PriorityQueueDFSOrderPattern, PriorityQueueOptions } from '../types';
 export declare class PriorityQueue<T = number> {
     protected nodes: T[];
-    get size(): number;
-    protected readonly _comparator: PriorityQueueComparator<T>;
+    /**
+     * The constructor initializes a priority queue with the given options, including an array of nodes and a comparator
+     * function.
+     * @param options - The `options` parameter is an object that contains the following properties:
+     */
     constructor(options: PriorityQueueOptions<T>);
-    protected _compare(a: number, b: number): boolean;
-    protected _swap(a: number, b: number): void;
-    protected _isValidIndex(index: number): boolean;
-    protected _getParent(child: number): number;
-    protected _getLeft(parent: number): number;
-    protected _getRight(parent: number): number;
-    protected _getComparedChild(parent: number): number;
-    protected _heapifyUp(start: number): void;
-    protected _heapifyDown(start: number): void;
-    protected _fix(): void;
+    get size(): number;
+    /**
+     * The `heapify` function creates a new PriorityQueue instance and fixes the heap property.
+     * @param options - The "options" parameter is an object that contains the configuration options for the PriorityQueue.
+     * It can include properties such as "comparator" which specifies the comparison function used to order the elements in
+     * the priority queue, and "initialValues" which is an array of initial values to be added to the priority
+     * @returns a new instance of the PriorityQueue class after performing the heapify operation on it.
+     */
+    static heapify<T>(options: PriorityQueueOptions<T>): PriorityQueue<T>;
+    /**
+     * The function checks if a priority queue is valid by creating a new priority queue with a fix option and then calling
+     * the isValid method.
+     * @param options - An object containing options for creating a priority queue. The options object should have the
+     * following properties:
+     * @returns the result of calling the `isValid()` method on a new instance of the `PriorityQueue` class.
+     */
+    static isPriorityQueueified<T>(options: Omit<PriorityQueueOptions<T>, 'isFix'>): boolean;
+    /**
+     * The "offer" function adds a node to the heap and ensures that the heap property is maintained.
+     * @param {T} node - The parameter "node" is of type T, which means it can be any data type. It represents the node
+     * that needs to be added to the heap.
+     */
     offer(node: T): void;
+    /**
+     * The `peek` function returns the first element of the `nodes` array if it exists, otherwise it returns `null`.
+     * @returns The `peek()` function is returning the first element (`T`) of the `nodes` array if the `size` is not zero.
+     * Otherwise, it returns `null`.
+     */
     peek(): T | null;
+    /**
+     * The `poll` function removes and returns the top element from a heap data structure.
+     * @returns The `poll()` method returns a value of type `T` or `null`.
+     */
     poll(): T | null;
+    /**
+     * The `leaf` function returns the last element in the `nodes` array or `null` if the array is empty.
+     * @returns The method `leaf()` is returning the last element (`T`) in the `nodes` array if it exists. If the array is
+     * empty or the last element is `null`, then it returns `null`.
+     */
     leaf(): T | null;
+    /**
+     * The function checks if the size of an object is equal to zero and returns a boolean value indicating whether the
+     * object is empty or not.
+     * @returns The method `isEmpty()` is returning a boolean value indicating whether the size of the object is equal to
+     * 0.
+     */
     isEmpty(): boolean;
+    /**
+     * The clear function clears the nodes array.
+     */
     clear(): void;
+    /**
+     * The toArray function returns an array containing all the elements in the nodes property.
+     * @returns An array of type T, which is the elements of the nodes property.
+     */
     toArray(): T[];
+    /**
+     * The `clone` function returns a new instance of the `PriorityQueue` class with the same nodes and comparator as the
+     * original instance.
+     * @returns The `clone()` method is returning a new instance of the `PriorityQueue` class with the same `nodes` and
+     * `comparator` properties as the original instance.
+     */
     clone(): PriorityQueue<T>;
+    /**
+     * The `isValid` function recursively checks if a binary tree satisfies a certain condition.
+     * @returns The function `isValid()` returns a boolean value.
+     */
     isValid(): boolean;
+    /**
+     * The function sorts the elements in a data structure and returns them in ascending order.
+     * @returns The `sort()` function is returning an array of type `T[]`.
+     */
     sort(): T[];
+    /**
+     * The DFS function performs a depth-first search traversal on a binary tree and returns an array of visited nodes
+     * based on the specified traversal order.
+     * @param {PriorityQueueDFSOrderPattern} dfsMode - The dfsMode parameter is a string that specifies the order in which
+     * the nodes should be visited during the Depth-First Search (DFS) traversal. It can have one of the following values:
+     * @returns an array of type `(T | null)[]`.
+     */
     DFS(dfsMode: PriorityQueueDFSOrderPattern): (T | null)[];
-    static heapify<T>(options: PriorityQueueOptions<T>): PriorityQueue<T>;
-    static isPriorityQueueified<T>(options: Omit<PriorityQueueOptions<T>, 'isFix'>): boolean;
+    protected readonly _comparator: PriorityQueueComparator<T>;
+    /**
+     * The function compares two numbers using a custom comparator function.
+     * @param {number} a - The parameter "a" is a number that represents the index of a node in an array.
+     * @param {number} b - The parameter "b" is a number.
+     * @returns the result of the comparison between the elements at indices `a` and `b` in the `nodes` array. The
+     * comparison is done using the `_comparator` function, and if the result is greater than 0, `true` is returned,
+     * indicating that the element at index `a` is greater than the element at index `b`.
+     */
+    protected _compare(a: number, b: number): boolean;
+    /**
+     * The function swaps two elements in an array.
+     * @param {number} a - The parameter "a" is a number that represents the index of an element in an array.
+     * @param {number} b - The parameter "b" is a number.
+     */
+    protected _swap(a: number, b: number): void;
+    /**
+     * The function checks if a given index is valid within an array.
+     * @param {number} index - The parameter "index" is of type number and represents the index value that needs to be
+     * checked for validity.
+     * @returns A boolean value indicating whether the given index is valid or not.
+     */
+    protected _isValidIndex(index: number): boolean;
+    /**
+     * The function returns the index of the parent node given the index of a child node in a binary tree.
+     * @param {number} child - The "child" parameter is a number representing the index of a child node in a binary tree.
+     * @returns the parent of the given child node.
+     */
+    protected _getParent(child: number): number;
+    /**
+     * The function returns the index of the left child node in a binary tree given the index of its parent node.
+     * @param {number} parent - The parameter "parent" is a number that represents the index of a node in a binary tree.
+     * @returns the left child of a given parent node in a binary tree.
+     */
+    protected _getLeft(parent: number): number;
+    /**
+     * The function returns the index of the right child node in a binary tree given the index of its parent node.
+     * @param {number} parent - The parameter "parent" is a number that represents the index of a node in a binary tree.
+     * @returns the right child of a given parent node in a binary tree.
+     */
+    protected _getRight(parent: number): number;
+    /**
+     * The function returns the index of the smallest child node of a given parent node.
+     * @param {number} parent - The parent parameter is a number that represents the index of the parent node in a binary
+     * tree.
+     * @returns the minimum value between the parent node and its left and right child nodes.
+     */
+    protected _getComparedChild(parent: number): number;
+    /**
+     * The function `_heapifyUp` is used to maintain the heap property by moving an element up the heap until it is in the
+     * correct position.
+     * @param {number} start - The start parameter is the index of the element that needs to be moved up in the heap.
+     */
+    protected _heapifyUp(start: number): void;
+    /**
+     * The function performs a heapify operation by comparing and swapping elements in a binary heap.
+     * @param {number} start - The start parameter is the index of the element in the heap from where the heapifyDown
+     * operation should start.
+     */
+    protected _heapifyDown(start: number): void;
+    /**
+     * The _fix function performs a heapify operation on the elements of the heap starting from the middle and moving
+     * towards the root.
+     */
+    protected _fix(): void;
 }