queue-typed 1.49.1 → 1.49.3

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -26,54 +26,53 @@ export declare class DoublyLinkedListNode<E = any> {
  */
 export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
     /**
-     * The constructor initializes the linked list with an empty head, tail, and length.
+     * The constructor initializes the linked list with an empty head, tail, and size.
      */
     constructor(elements?: Iterable<E>);
     protected _head: DoublyLinkedListNode<E> | undefined;
     get head(): DoublyLinkedListNode<E> | undefined;
     protected _tail: DoublyLinkedListNode<E> | undefined;
     get tail(): DoublyLinkedListNode<E> | undefined;
-    protected _length: number;
-    get length(): number;
+    protected _size: number;
     get size(): number;
     /**
-     * Time Complexity: O(n), where n is the length of the input array.
+     * Time Complexity: O(n), where n is the size of the input array.
      * Space Complexity: O(n)
      */
     /**
-     * Time Complexity: O(n), where n is the length of the input array.
-     * Space Complexity: O(n)
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
      *
-     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
-     * given array.
-     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
-     * @returns The `fromArray` function returns a DoublyLinkedList object.
+     * The `get first` function returns the first node in a doubly linked list, or undefined if the list is empty.
+     * @returns The method `get first()` returns the first node of the doubly linked list, or `undefined` if the list is empty.
      */
-    static fromArray<E>(data: E[]): DoublyLinkedList<E>;
+    get first(): E | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      *
-     * The push function adds a new node with the given value to the end of the doubly linked list.
-     * @param {E} value - The value to be added to the linked list.
+     * The `get last` function returns the last node in a doubly linked list, or undefined if the list is empty.
+     * @returns The method `get last()` returns the last node of the doubly linked list, or `undefined` if the list is empty.
      */
-    push(value: E): void;
+    get last(): E | undefined;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
+     * Time Complexity: O(n), where n is the size of the input array.
+     * Space Complexity: O(n)
      *
-     * The addLast function adds a new node with the given value to the end of the doubly linked list.
-     * @param {E} value - The value to be added to the linked list.
+     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
+     * given array.
+     * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
+     * @returns The `fromArray` function returns a DoublyLinkedList object.
      */
-    addLast(value: E): void;
+    static fromArray<E>(data: E[]): DoublyLinkedList<E>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -82,11 +81,10 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `pop()` function removes and returns the value of the last node in a doubly linked list.
-     * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
-     * list is empty, it returns undefined.
+     * The push function adds a new node with the given value to the end of the doubly linked list.
+     * @param {E} value - The value to be added to the linked list.
      */
-    pop(): E | undefined;
+    push(value: E): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -95,13 +93,13 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
+     * The `pop()` function removes and returns the value of the last node in a doubly linked list.
      * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
      * list is empty, it returns undefined.
      */
-    pollLast(): E | undefined;
+    pop(): E | undefined;
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      */
     /**
@@ -114,20 +112,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     shift(): E | undefined;
     /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
-     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
-     * list.
-     */
-    pollFirst(): E | undefined;
-    /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      */
     /**
@@ -138,44 +123,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
      * doubly linked list.
      */
-    unshift(value: E): void;
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(1)
-     *
-     * The addFirst function adds a new node with the given value to the beginning of a doubly linked list.
-     * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
-     * doubly linked list.
-     */
-    addFirst(value: E): void;
-    /**
-     * 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 elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * The `getFirst` function returns the first node in a doubly linked list, or undefined if the list is empty.
-     * @returns The method `getFirst()` returns the first node of the doubly linked list, or `undefined` if the list is empty.
-     */
-    getFirst(): E | undefined;
-    /**
-     * 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 elements in the linked list.
-     * Space Complexity: O(1)
-     *
-     * The `getLast` function returns the last node in a doubly linked list, or undefined if the list is empty.
-     * @returns The method `getLast()` returns the last node of the doubly linked list, or `undefined` if the list is empty.
-     */
-    getLast(): E | undefined;
+    unshift(value: E): boolean;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -238,7 +186,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
      * if the index is out of bounds.
      */
-    insertAt(index: number, value: E): boolean;
+    addAt(index: number, value: E): boolean;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -247,7 +195,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      *
-     * The `insertBefore` function inserts a new value before an existing value or node in a doubly linked list.
+     * The `addBefore` function inserts a new value before an existing value or node in a doubly linked list.
      * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
      * before which the new value will be inserted. It can be either the value of the existing node or the existing node
      * itself.
@@ -256,7 +204,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * @returns The method returns a boolean value. It returns `true` if the insertion is successful, and `false` if the
      * insertion fails.
      */
-    insertBefore(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
+    addBefore(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -265,7 +213,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      *
-     * The `insertAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
+     * The `addAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
      * @param {E | DoublyLinkedListNode<E>} existingValueOrNode - The existing value or node in the doubly linked list
      * after which the new value will be inserted. It can be either the value of the existing node or the existing node
      * itself.
@@ -273,11 +221,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * @returns The method returns a boolean value. It returns true if the insertion is successful, and false if the
      * existing value or node is not found in the doubly linked list.
      */
-    insertAfter(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     */
+    addAfter(existingValueOrNode: E | DoublyLinkedListNode<E>, newValue: E): boolean;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -288,11 +232,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * @returns The method `deleteAt` returns the value of the node that was deleted, or `undefined` if the index is out of
      * bounds.
      */
-    deleteAt(index: number): E | undefined;
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
-     */
+    deleteAt(index: number): boolean;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -305,12 +245,20 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     delete(valOrNode: E | DoublyLinkedListNode<E> | undefined): boolean;
     /**
-     * The function checks if a variable has a length greater than zero and returns a boolean value.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * The function checks if a variable has a size greater than zero and returns a boolean value.
      * @returns A boolean value is being returned.
      */
     isEmpty(): boolean;
     /**
-     * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * The `clear` function resets the linked list by setting the head, tail, and size to undefined and 0 respectively.
      */
     clear(): void;
     /**
@@ -345,7 +293,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
     indexOf(value: E): number;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -361,7 +309,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
     findBackward(callback: (value: E) => boolean): E | undefined;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(1)
+     * Space Complexity: O(n)
      */
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
@@ -369,9 +317,9 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      *
      * The `reverse` function reverses the order of the elements in a doubly linked list.
      */
-    reverse(): void;
+    reverse(): this;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
@@ -395,8 +343,8 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     toReversedArray(): E[];
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -417,8 +365,8 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     filter(callback: ElementCallback<E, boolean>, thisArg?: any): DoublyLinkedList<E>;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -438,11 +386,57 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * object.
      */
     map<T>(callback: ElementCallback<E, T>, thisArg?: any): DoublyLinkedList<T>;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The addLast function adds a new node with the given value to the end of the doubly linked list.
+     * @param {E} value - The value to be added to the linked list.
+     */
+    addLast(value: E): boolean;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `pollLast()` function removes and returns the value of the last node in a doubly linked list.
+     * @returns The method is returning the value of the removed node (removedNode.value) if the list is not empty. If the
+     * list is empty, it returns undefined.
+     */
+    pollLast(): E | undefined;
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
+     * Space Complexity: O(1)
      */
-    print(): void;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The `pollFirst()` function removes and returns the value of the first node in a doubly linked list.
+     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
+     * list.
+     */
+    pollFirst(): E | undefined;
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     *
+     * The addFirst function adds a new node with the given value to the beginning of a doubly linked list.
+     * @param {E} value - The `value` parameter represents the value of the new node that will be added to the beginning of the
+     * doubly linked list.
+     */
+    addFirst(value: E): void;
     /**
      * The function returns an iterator that iterates over the values of a linked list.
      */