data-structure-typed 1.40.0-rc → 1.40.0

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

@@ -1,270 +0,0 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
-import { DoublyLinkedList } from '../linked-list';
-// O(n) time complexity of obtaining the value
-// O(1) time complexity of adding at the beginning and the end
-export class Deque extends DoublyLinkedList {
-}
-// O(1) time complexity of obtaining the value
-// O(n) time complexity of adding at the beginning and the end
-// todo tested slowest one
-export 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;
-    }
-    set capacity(value) {
-        this._capacity = value;
-    }
-    get first() {
-        return this._first;
-    }
-    set first(value) {
-        this._first = value;
-    }
-    get last() {
-        return this._last;
-    }
-    set last(value) {
-        this._last = value;
-    }
-    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 `pollFirst()` removes and returns the first element in a data structure.
-     * @returns The value of the first element in the data structure.
-     */
-    pollFirst() {
-        if (!this._size)
-            return;
-        const value = this.peekFirst();
-        delete this._nodes[this._first];
-        this._first++;
-        this._size--;
-        return value;
-    }
-    /**
-     * The `peekFirst` 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.
-     */
-    peekFirst() {
-        if (this._size)
-            return this._nodes[this._first];
-    }
-    /**
-     * The `pollLast()` function removes and returns the last element in a data structure.
-     * @returns The value that was removed from the data structure.
-     */
-    pollLast() {
-        if (!this._size)
-            return;
-        const value = this.peekLast();
-        delete this._nodes[this._last];
-        this._last--;
-        this._size--;
-        return value;
-    }
-    /**
-     * The `peekLast()` function returns the last element in an array-like data structure.
-     * @returns The last element in the array "_nodes" is being returned.
-     */
-    peekLast() {
-        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;
-    }
-    _seNodes(value) {
-        this._nodes = value;
-    }
-    _setSize(value) {
-        this._size = value;
-    }
-}
-// O(1) time complexity of obtaining the value
-// O(n) time complexity of adding at the beginning and the end
-export class ArrayDeque {
-    constructor() {
-        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 "pollLast" returns and removes the last element from an array, or returns null if the array is empty.
-     * @returns The method `pollLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
-     */
-    pollLast() {
-        var _a;
-        return (_a = this._nodes.pop()) !== null && _a !== void 0 ? _a : null;
-    }
-    /**
-     * The `pollFirst` function removes and returns the first element from an array, or returns null if the array is empty.
-     * @returns The `pollFirst()` function returns the first element of the `_nodes` array, or `null` if the array is
-     * empty.
-     */
-    pollFirst() {
-        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 `peekFirst` function returns the first element of an array or null if the array is empty.
-     * @returns The function `peekFirst()` is returning the first element (`E`) of the `_nodes` array. If the array is
-     * empty, it will return `null`.
-     */
-    peekFirst() {
-        var _a;
-        return (_a = this._nodes[0]) !== null && _a !== void 0 ? _a : null;
-    }
-    /**
-     * The `peekLast` function returns the last element of an array or null if the array is empty.
-     * @returns The method `peekLast()` returns the last element of the `_nodes` array, or `null` if the array is empty.
-     */
-    peekLast() {
-        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 remove 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.
-     */
-    remove(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;
-    }
-}

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

@@ -1,107 +0,0 @@
-/**
- * @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 `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[]);
-    private _nodes;
-    get nodes(): E[];
-    set nodes(value: E[]);
-    private _offset;
-    get offset(): number;
-    set offset(value: 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 `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 `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>;
-}

package/lib/data-structures/queue/queue.js

@@ -1,165 +0,0 @@
-/**
- * @license MIT
- * @copyright Tyler Zeng <zrwusa@gmail.com>
- * @class
- */
-import { SinglyLinkedList } from '../linked-list';
-export class LinkedListQueue extends SinglyLinkedList {
-    /**
-     * 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) {
-        this.push(value);
-    }
-    /**
-     * 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() {
-        return this.shift();
-    }
-    /**
-     * 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() {
-        var _a;
-        return (_a = this.head) === null || _a === void 0 ? void 0 : _a.val;
-    }
-}
-export class Queue {
-    /**
-     * 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) {
-        this._nodes = elements || [];
-        this._offset = 0;
-    }
-    get nodes() {
-        return this._nodes;
-    }
-    set nodes(value) {
-        this._nodes = value;
-    }
-    get offset() {
-        return this._offset;
-    }
-    set offset(value) {
-        this._offset = value;
-    }
-    /**
-     * 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() {
-        return this.nodes.length - this.offset;
-    }
-    /**
-     * 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(elements) {
-        return new Queue(elements);
-    }
-    /**
-     * 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) {
-        this.nodes.push(element);
-        return this;
-    }
-    /**
-     * 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() {
-        if (this.size === 0)
-            return undefined;
-        const first = this.peek();
-        this.offset += 1;
-        if (this.offset * 2 < this.nodes.length)
-            return first;
-        // only remove dequeued elements when reaching half size
-        // to decrease latency of shifting elements.
-        this.nodes = this.nodes.slice(this.offset);
-        this.offset = 0;
-        return first;
-    }
-    /**
-     * 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() {
-        return this.size > 0 ? this.nodes[this.offset] : 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() {
-        return this.size > 0 ? this.nodes[this.nodes.length - 1] : 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) {
-        this.push(value);
-    }
-    /**
-     * 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() {
-        return this.shift();
-    }
-    getAt(index) {
-        return this.nodes[index];
-    }
-    /**
-     * 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() {
-        return this.size === 0;
-    }
-    /**
-     * 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() {
-        return this.nodes.slice(this.offset);
-    }
-    /**
-     * The clear function resets the nodes array and offset to their initial values.
-     */
-    clear() {
-        this.nodes = [];
-        this.offset = 0;
-    }
-    /**
-     * 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() {
-        return new Queue(this.nodes.slice(this.offset));
-    }
-    *[Symbol.iterator]() {
-        for (const item of this.nodes) {
-            yield item;
-        }
-    }
-}

package/lib/data-structures/stack/stack.d.ts

@@ -1,63 +0,0 @@
-/**
- * @license MIT
- * @copyright Tyler Zeng <zrwusa@gmail.com>
- * @class
- */
-export declare class Stack<E = any> {
-    protected _elements: E[];
-    /**
-     * The constructor initializes an array of elements, which can be provided as an optional parameter.
-     * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
-     * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
-     * is provided and is an array, it is assigned to the `_elements
-     */
-    constructor(elements?: E[]);
-    /**
-     * The function "fromArray" creates a new Stack object from an array of elements.
-     * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
-     * @returns {Stack} The method is returning a new instance of the Stack class, initialized with the elements from the input
-     * array.
-     */
-    static fromArray<E>(elements: E[]): Stack<E>;
-    /**
-     * The function checks if an array is empty and returns a boolean value.
-     * @returns A boolean value indicating whether the `_elements` array is empty or not.
-     */
-    isEmpty(): boolean;
-    /**
-     * The size() function returns the number of elements in an array.
-     * @returns The size of the elements array.
-     */
-    size(): number;
-    /**
-     * The `peek` function returns the last element of an array, or null if the array is empty.
-     * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
-     */
-    peek(): E | null;
-    /**
-     * The push function adds an element to the stack and returns the updated stack.
-     * @param {E} element - The parameter "element" is of type E, which means it can be any data type.
-     * @returns The `push` method is returning the updated `Stack<E>` object.
-     */
-    push(element: E): Stack<E>;
-    /**
-     * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
-     * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
-     * array is empty, it returns `null`.
-     */
-    pop(): E | null;
-    /**
-     * The toArray function returns a copy of the elements in an array.
-     * @returns An array of type E.
-     */
-    toArray(): E[];
-    /**
-     * The clear function clears the elements array.
-     */
-    clear(): void;
-    /**
-     * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
-     * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
-     */
-    clone(): Stack<E>;
-}

package/lib/data-structures/stack/stack.js

@@ -1,87 +0,0 @@
-/**
- * @license MIT
- * @copyright Tyler Zeng <zrwusa@gmail.com>
- * @class
- */
-export class Stack {
-    /**
-     * The constructor initializes an array of elements, which can be provided as an optional parameter.
-     * @param {E[]} [elements] - The `elements` parameter is an optional parameter of type `E[]`, which represents an array
-     * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
-     * is provided and is an array, it is assigned to the `_elements
-     */
-    constructor(elements) {
-        this._elements = Array.isArray(elements) ? elements : [];
-    }
-    /**
-     * The function "fromArray" creates a new Stack object from an array of elements.
-     * @param {E[]} elements - The `elements` parameter is an array of elements of type `E`.
-     * @returns {Stack} The method is returning a new instance of the Stack class, initialized with the elements from the input
-     * array.
-     */
-    static fromArray(elements) {
-        return new Stack(elements);
-    }
-    /**
-     * The function checks if an array is empty and returns a boolean value.
-     * @returns A boolean value indicating whether the `_elements` array is empty or not.
-     */
-    isEmpty() {
-        return this._elements.length === 0;
-    }
-    /**
-     * The size() function returns the number of elements in an array.
-     * @returns The size of the elements array.
-     */
-    size() {
-        return this._elements.length;
-    }
-    /**
-     * The `peek` function returns the last element of an array, or null if the array is empty.
-     * @returns The `peek()` function returns the last element of the `_elements` array, or `null` if the array is empty.
-     */
-    peek() {
-        if (this.isEmpty())
-            return null;
-        return this._elements[this._elements.length - 1];
-    }
-    /**
-     * The push function adds an element to the stack and returns the updated stack.
-     * @param {E} element - The parameter "element" is of type E, which means it can be any data type.
-     * @returns The `push` method is returning the updated `Stack<E>` object.
-     */
-    push(element) {
-        this._elements.push(element);
-        return this;
-    }
-    /**
-     * The `pop` function removes and returns the last element from an array, or returns null if the array is empty.
-     * @returns The `pop()` method is returning the last element of the array `_elements` if the array is not empty. If the
-     * array is empty, it returns `null`.
-     */
-    pop() {
-        if (this.isEmpty())
-            return null;
-        return this._elements.pop() || null;
-    }
-    /**
-     * The toArray function returns a copy of the elements in an array.
-     * @returns An array of type E.
-     */
-    toArray() {
-        return this._elements.slice();
-    }
-    /**
-     * The clear function clears the elements array.
-     */
-    clear() {
-        this._elements = [];
-    }
-    /**
-     * The `clone()` function returns a new `Stack` object with the same elements as the original stack.
-     * @returns The `clone()` method is returning a new `Stack` object with a copy of the `_elements` array.
-     */
-    clone() {
-        return new Stack(this._elements.slice());
-    }
-}