min-heap-typed 1.40.0-rc → 1.41.0

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

@@ -0,0 +1,15 @@
+/**
+ * data-structure-typed
+ *
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @license MIT License
+ */
+import { PriorityQueue } from './priority-queue';
+import type { Comparator } from '../../types';
+export declare class MinPriorityQueue<E = any> extends PriorityQueue<E> {
+    constructor(options?: {
+        comparator: Comparator<E>;
+        nodes?: E[];
+    });
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinPriorityQueue = void 0;
+/**
+ * data-structure-typed
+ *
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @license MIT License
+ */
+const priority_queue_1 = require("./priority-queue");
+class MinPriorityQueue extends priority_queue_1.PriorityQueue {
+    constructor(options = {
+        comparator: (a, b) => {
+            if (!(typeof a === 'number' && typeof b === 'number')) {
+                throw new Error('The a, b params of compare function must be number');
+            }
+            else {
+                return a - b;
+            }
+        }
+    }) {
+        super(options);
+    }
+}
+exports.MinPriorityQueue = MinPriorityQueue;

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

@@ -0,0 +1,15 @@
+/**
+ * data-structure-typed
+ *
+ * @author Kirk Qi
+ * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
+ * @license MIT License
+ */
+import { Heap } from '../heap';
+import { Comparator } from '../../types';
+export declare class PriorityQueue<E = any> extends Heap<E> {
+    constructor(options: {
+        comparator: Comparator<E>;
+        nodes?: E[];
+    });
+}

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

@@ -0,0 +1,17 @@
+"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");
+class PriorityQueue extends heap_1.Heap {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.PriorityQueue = PriorityQueue;

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

@@ -0,0 +1,161 @@
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import { DoublyLinkedList } from '../linked-list';
+export declare class Deque<E = any> extends DoublyLinkedList<E> {
+}
+export declare class ObjectDeque<E = number> {
+    constructor(capacity?: number);
+    protected _nodes: {
+        [key: number]: E;
+    };
+    get nodes(): {
+        [p: number]: E;
+    };
+    protected _capacity: number;
+    get capacity(): number;
+    protected _first: number;
+    get first(): number;
+    protected _last: number;
+    get last(): number;
+    protected _size: number;
+    get size(): number;
+    /**
+     * The "addFirst" function adds a value to the beginning of an array-like data structure.
+     * @param {E} value - The `value` parameter represents the value that you want to add to the beginning of the data
+     * structure.
+     */
+    addFirst(value: E): void;
+    /**
+     * The addLast function adds a value to the end of an array-like data structure.
+     * @param {E} value - The `value` parameter represents the value that you want to add to the end of the data structure.
+     */
+    addLast(value: E): void;
+    /**
+     * The function `popFirst()` removes and returns the first element in a data structure.
+     * @returns The value of the first element in the data structure.
+     */
+    popFirst(): E | undefined;
+    /**
+     * The `getFirst` function returns the first element in an array-like data structure if it exists.
+     * @returns The element at the first position of the `_nodes` array.
+     */
+    getFirst(): E | undefined;
+    /**
+     * The `popLast()` function removes and returns the last element in a data structure.
+     * @returns The value that was removed from the data structure.
+     */
+    popLast(): E | undefined;
+    /**
+     * The `getLast()` function returns the last element in an array-like data structure.
+     * @returns The last element in the array "_nodes" is being returned.
+     */
+    getLast(): E | undefined;
+    /**
+     * The get function returns the element at the specified index in an array-like data structure.
+     * @param {number} index - The index parameter is a number that represents the position of the element you want to
+     * retrieve from the array.
+     * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
+     * index, `null` is returned.
+     */
+    get(index: number): NonNullable<E> | null;
+    /**
+     * The function checks if the size of a data structure is less than or equal to zero.
+     * @returns The method is returning a boolean value indicating whether the size of the object is less than or equal to 0.
+     */
+    isEmpty(): boolean;
+}
+export declare class ArrayDeque<E> {
+    protected _nodes: E[];
+    get nodes(): E[];
+    get size(): number;
+    /**
+     * O(n) time complexity of adding at the beginning and the end
+     */
+    /**
+     * The function "addLast" adds a value to the end of an array.
+     * @param {E} value - The value parameter represents the value that you want to add to the end of the array.
+     * @returns The return value is the new length of the array after the value has been added.
+     */
+    addLast(value: E): number;
+    /**
+     * The function "popLast" returns and removes the last element from an array, or returns null if the array is empty.
+     * @returns The method `popLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     */
+    popLast(): E | null;
+    /**
+     * The `popFirst` function removes and returns the first element from an array, or returns null if the array is empty.
+     * @returns The `popFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
+     * empty.
+     */
+    popFirst(): E | null;
+    /**
+     * O(n) time complexity of adding at the beginning and the end
+     */
+    /**
+     * The function "addFirst" adds a value to the beginning of an array.
+     * @param {E} value - The value parameter represents the value that you want to add to the beginning of the array.
+     * @returns The return value of the `addFirst` function is the new length of the array `_nodes` after adding the
+     * `value` at the beginning.
+     */
+    addFirst(value: E): number;
+    /**
+     * The `getFirst` function returns the first element of an array or null if the array is empty.
+     * @returns The function `getFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
+     * empty, it will return `null`.
+     */
+    getFirst(): E | null;
+    /**
+     * The `getLast` function returns the last element of an array or null if the array is empty.
+     * @returns The method `getLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     */
+    getLast(): E | null;
+    /**
+     * O(1) time complexity of obtaining the value
+     */
+    /**
+     * The get function returns the element at the specified index in an array, or null if the index is out of bounds.
+     * @param {number} index - The index parameter is a number that represents the position of the element you want to
+     * retrieve from the array.
+     * @returns The method is returning the element at the specified index in the `_nodes` array. If the element exists, it
+     * will be returned. If the element does not exist (i.e., the index is out of bounds), `null` will be returned.
+     */
+    get(index: number): E | null;
+    /**
+     * The set function assigns a value to a specific index in an array.
+     * @param {number} index - The index parameter is a number that represents the position of the element in the array
+     * that you want to set a new value for.
+     * @param {E} value - The value parameter represents the new value that you want to set at the specified index in the
+     * _nodes array.
+     * @returns The value that is being set at the specified index in the `_nodes` array.
+     */
+    set(index: number, value: E): E;
+    /**
+     * The insert function adds a value at a specified index in an array.
+     * @param {number} index - The index parameter specifies the position at which the value should be inserted in the
+     * array. It is a number that represents the index of the array where the value should be inserted. The index starts
+     * from 0, so the first element of the array has an index of 0, the second element has
+     * @param {E} value - The value parameter represents the value that you want to insert into the array at the specified
+     * index.
+     * @returns The splice method returns an array containing the removed elements, if any. In this case, since no elements
+     * are being removed, an empty array will be returned.
+     */
+    insert(index: number, value: E): E[];
+    /**
+     * 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.
+     */
+    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
+     * is 0, indicating that the array is empty. Otherwise, it returns `false`.
+     */
+    isEmpty(): boolean;
+}

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

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayDeque = exports.ObjectDeque = exports.Deque = void 0;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+const linked_list_1 = require("../linked-list");
+// O(n) time complexity of obtaining the value
+// O(1) time complexity of adding at the beginning and the end
+class Deque extends linked_list_1.DoublyLinkedList {
+}
+exports.Deque = Deque;
+// O(1) time complexity of obtaining the value
+// O(n) time complexity of adding at the beginning and the end
+// todo tested slowest one
+class ObjectDeque {
+    constructor(capacity) {
+        this._nodes = {};
+        this._capacity = Number.MAX_SAFE_INTEGER;
+        this._first = -1;
+        this._last = -1;
+        this._size = 0;
+        if (capacity !== undefined)
+            this._capacity = capacity;
+    }
+    get nodes() {
+        return this._nodes;
+    }
+    get capacity() {
+        return this._capacity;
+    }
+    get first() {
+        return this._first;
+    }
+    get last() {
+        return this._last;
+    }
+    get size() {
+        return this._size;
+    }
+    /**
+     * The "addFirst" function adds a value to the beginning of an array-like data structure.
+     * @param {E} value - The `value` parameter represents the value that you want to add to the beginning of the data
+     * structure.
+     */
+    addFirst(value) {
+        if (this.size === 0) {
+            const mid = Math.floor(this.capacity / 2);
+            this._first = mid;
+            this._last = mid;
+        }
+        else {
+            this._first--;
+        }
+        this.nodes[this.first] = value;
+        this._size++;
+    }
+    /**
+     * The addLast function adds a value to the end of an array-like data structure.
+     * @param {E} value - The `value` parameter represents the value that you want to add to the end of the data structure.
+     */
+    addLast(value) {
+        if (this.size === 0) {
+            const mid = Math.floor(this.capacity / 2);
+            this._first = mid;
+            this._last = mid;
+        }
+        else {
+            this._last++;
+        }
+        this.nodes[this.last] = value;
+        this._size++;
+    }
+    /**
+     * The function `popFirst()` removes and returns the first element in a data structure.
+     * @returns The value of the first element in the data structure.
+     */
+    popFirst() {
+        if (!this.size)
+            return;
+        const value = this.getFirst();
+        delete this.nodes[this.first];
+        this._first++;
+        this._size--;
+        return value;
+    }
+    /**
+     * The `getFirst` function returns the first element in an array-like data structure if it exists.
+     * @returns The element at the first position of the `_nodes` array.
+     */
+    getFirst() {
+        if (this.size)
+            return this.nodes[this.first];
+    }
+    /**
+     * The `popLast()` function removes and returns the last element in a data structure.
+     * @returns The value that was removed from the data structure.
+     */
+    popLast() {
+        if (!this.size)
+            return;
+        const value = this.getLast();
+        delete this.nodes[this.last];
+        this._last--;
+        this._size--;
+        return value;
+    }
+    /**
+     * The `getLast()` function returns the last element in an array-like data structure.
+     * @returns The last element in the array "_nodes" is being returned.
+     */
+    getLast() {
+        if (this.size)
+            return this.nodes[this.last];
+    }
+    /**
+     * The get function returns the element at the specified index in an array-like data structure.
+     * @param {number} index - The index parameter is a number that represents the position of the element you want to
+     * retrieve from the array.
+     * @returns The element at the specified index in the `_nodes` array is being returned. If there is no element at that
+     * index, `null` is returned.
+     */
+    get(index) {
+        return this.nodes[this.first + index] || null;
+    }
+    /**
+     * The function checks if the size of a data structure is less than or equal to zero.
+     * @returns The method is returning a boolean value indicating whether the size of the object is less than or equal to 0.
+     */
+    isEmpty() {
+        return this.size <= 0;
+    }
+}
+exports.ObjectDeque = ObjectDeque;
+// O(1) time complexity of obtaining the value
+// O(n) time complexity of adding at the beginning and the end
+class ArrayDeque {
+    constructor() {
+        this._nodes = [];
+    }
+    get nodes() {
+        return this._nodes;
+    }
+    get size() {
+        return this.nodes.length;
+    }
+    /**
+     * O(n) time complexity of adding at the beginning and the end
+     */
+    /**
+     * The function "addLast" adds a value to the end of an array.
+     * @param {E} value - The value parameter represents the value that you want to add to the end of the array.
+     * @returns The return value is the new length of the array after the value has been added.
+     */
+    addLast(value) {
+        return this.nodes.push(value);
+    }
+    /**
+     * The function "popLast" returns and removes the last element from an array, or returns null if the array is empty.
+     * @returns The method `popLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     */
+    popLast() {
+        var _a;
+        return (_a = this.nodes.pop()) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * The `popFirst` function removes and returns the first element from an array, or returns null if the array is empty.
+     * @returns The `popFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
+     * empty.
+     */
+    popFirst() {
+        var _a;
+        return (_a = this.nodes.shift()) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * O(n) time complexity of adding at the beginning and the end
+     */
+    /**
+     * The function "addFirst" adds a value to the beginning of an array.
+     * @param {E} value - The value parameter represents the value that you want to add to the beginning of the array.
+     * @returns The return value of the `addFirst` function is the new length of the array `_nodes` after adding the
+     * `value` at the beginning.
+     */
+    addFirst(value) {
+        return this.nodes.unshift(value);
+    }
+    /**
+     * The `getFirst` function returns the first element of an array or null if the array is empty.
+     * @returns The function `getFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
+     * empty, it will return `null`.
+     */
+    getFirst() {
+        var _a;
+        return (_a = this.nodes[0]) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * The `getLast` function returns the last element of an array or null if the array is empty.
+     * @returns The method `getLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
+     */
+    getLast() {
+        var _a;
+        return (_a = this.nodes[this.nodes.length - 1]) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * O(1) time complexity of obtaining the value
+     */
+    /**
+     * The get function returns the element at the specified index in an array, or null if the index is out of bounds.
+     * @param {number} index - The index parameter is a number that represents the position of the element you want to
+     * retrieve from the array.
+     * @returns The method is returning the element at the specified index in the `_nodes` array. If the element exists, it
+     * will be returned. If the element does not exist (i.e., the index is out of bounds), `null` will be returned.
+     */
+    get(index) {
+        var _a;
+        return (_a = this.nodes[index]) !== null && _a !== void 0 ? _a : null;
+    }
+    /**
+     * The set function assigns a value to a specific index in an array.
+     * @param {number} index - The index parameter is a number that represents the position of the element in the array
+     * that you want to set a new value for.
+     * @param {E} value - The value parameter represents the new value that you want to set at the specified index in the
+     * _nodes array.
+     * @returns The value that is being set at the specified index in the `_nodes` array.
+     */
+    set(index, value) {
+        return (this.nodes[index] = value);
+    }
+    /**
+     * The insert function adds a value at a specified index in an array.
+     * @param {number} index - The index parameter specifies the position at which the value should be inserted in the
+     * array. It is a number that represents the index of the array where the value should be inserted. The index starts
+     * from 0, so the first element of the array has an index of 0, the second element has
+     * @param {E} value - The value parameter represents the value that you want to insert into the array at the specified
+     * index.
+     * @returns The splice method returns an array containing the removed elements, if any. In this case, since no elements
+     * are being removed, an empty array will be returned.
+     */
+    insert(index, value) {
+        return this.nodes.splice(index, 0, value);
+    }
+    /**
+     * 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.
+     */
+    delete(index) {
+        return this.nodes.splice(index, 1);
+    }
+    /**
+     * 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
+     * is 0, indicating that the array is empty. Otherwise, it returns `false`.
+     */
+    isEmpty() {
+        return this.nodes.length === 0;
+    }
+}
+exports.ArrayDeque = ArrayDeque;

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

@@ -0,0 +1,2 @@
+export * from './queue';
+export * from './deque';

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./queue"), exports);
+__exportStar(require("./deque"), exports);

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

@@ -0,0 +1,122 @@
+/**
+ * @license MIT
+ * @copyright Tyler Zeng <zrwusa@gmail.com>
+ * @class
+ */
+import { SinglyLinkedList } from '../linked-list';
+export declare class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
+    /**
+     * The enqueue function adds a value to the end of an array.
+     * @param {E} value - The value parameter represents the value that you want to add to the queue.
+     */
+    enqueue(value: E): void;
+    /**
+     * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
+     * @returns The method is returning the element at the front of the queue, or null if the queue is empty.
+     */
+    dequeue(): E | undefined;
+    /**
+     * The `getFirst` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `getFirst()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     */
+    getFirst(): E | undefined;
+    /**
+     * The `peek` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
+     */
+    peek(): E | undefined;
+}
+export declare class Queue<E = any> {
+    /**
+     * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
+     * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
+     * will be used to initialize the `_nodes` property of the class. If not provided, the `_nodes` property will be
+     * initialized as an empty array.
+     */
+    constructor(elements?: E[]);
+    protected _nodes: E[];
+    get nodes(): E[];
+    protected _offset: number;
+    get offset(): number;
+    /**
+     * The size function returns the number of elements in an array.
+     * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
+     */
+    get size(): number;
+    /**
+     * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
+     * @public
+     * @static
+     * @param {E[]} elements - The "elements" parameter is an array of elements of type E.
+     * @returns The method is returning a new instance of the Queue class, initialized with the elements from the input
+     * array.
+     */
+    static fromArray<E>(elements: E[]): Queue<E>;
+    /**
+     * The push function adds an element to the end of the queue and returns the updated queue.Adds an element at the back of the queue.
+     * @param {E} element - The `element` parameter represents the element that you want to add to the queue.
+     * @returns The `add` method is returning a `Queue<E>` object.
+     */
+    push(element: E): Queue<E>;
+    /**
+     * The `shift` function removes and returns the first element in the queue, and adjusts the internal data structure if
+     * necessary to optimize performance.
+     * @returns The function `shift()` returns either the first element in the queue or `null` if the queue is empty.
+     */
+    shift(): E | undefined;
+    /**
+     * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
+     * @returns The `getFirst()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
+     */
+    getFirst(): E | undefined;
+    /**
+     * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `null`.
+     * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * the `_offset` index. If the data structure is empty (size is 0), it returns `null`.
+     */
+    peek(): E | undefined;
+    /**
+     * The `getLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+     * @returns The method `getLast()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * array is empty, it returns `null`.
+     */
+    getLast(): E | undefined;
+    /**
+     * The `peekLast` function returns the last element in an array-like data structure, or null if the structure is empty.
+     * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * array is empty, it returns `null`.
+     */
+    peekLast(): E | undefined;
+    /**
+     * The enqueue function adds a value to the end of a queue.
+     * @param {E} value - The value parameter represents the value that you want to add to the queue.
+     */
+    enqueue(value: E): void;
+    /**
+     * The `dequeue` function removes and returns the first element from a queue, or returns null if the queue is empty.
+     * @returns The method is returning a value of type E or null.
+     */
+    dequeue(): E | undefined;
+    getAt(index: number): E | undefined;
+    /**
+     * The function checks if a data structure is empty by comparing its size to zero.
+     * @returns {boolean} A boolean value indicating whether the size of the object is 0 or not.
+     */
+    isEmpty(): boolean;
+    /**
+     * The toArray() function returns an array of elements from the current offset to the end of the _nodes array.
+     * @returns An array of type E is being returned.
+     */
+    toArray(): E[];
+    /**
+     * The clear function resets the nodes array and offset to their initial values.
+     */
+    clear(): void;
+    /**
+     * The `clone()` function returns a new Queue object with the same elements as the original Queue.
+     * @returns The `clone()` method is returning a new instance of the `Queue` class.
+     */
+    clone(): Queue<E>;
+    [Symbol.iterator](): Generator<E, void, unknown>;
+}