data-structure-typed 1.49.0 → 1.49.2

package/dist/mjs/data-structures/linked-list/singly-linked-list.js

@@ -1,11 +1,4 @@
 import { IterableElementBase } from "../base";
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
 export class SinglyLinkedListNode {
     value;
     next;
@@ -27,7 +20,7 @@ export class SinglyLinkedList extends IterableElementBase {
         super();
         this._head = undefined;
         this._tail = undefined;
-        this._length = 0;
+        this._size = 0;
         if (elements) {
             for (const el of elements)
                 this.push(el);
@@ -41,9 +34,9 @@ export class SinglyLinkedList extends IterableElementBase {
     get tail() {
         return this._tail;
     }
-    _length;
-    get length() {
-        return this._length;
+    _size;
+    get size() {
+        return this._size;
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the input array, as it performs a loop to push each element into the linked list.
@@ -87,7 +80,8 @@ export class SinglyLinkedList extends IterableElementBase {
             this.tail.next = newNode;
             this._tail = newNode;
         }
-        this._length++;
+        this._size++;
+        return true;
     }
     /**
      * Time Complexity: O(1) - Constant time, as it involves basic pointer adjustments.
@@ -102,7 +96,7 @@ export class SinglyLinkedList extends IterableElementBase {
      * any type (E) as specified in the generic type declaration of the class or function.
      */
     addLast(value) {
-        this.push(value);
+        return this.push(value);
     }
     /**
      * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
@@ -124,7 +118,7 @@ export class SinglyLinkedList extends IterableElementBase {
             const value = this.head.value;
             this._head = undefined;
             this._tail = undefined;
-            this._length--;
+            this._size--;
             return value;
         }
         let current = this.head;
@@ -134,7 +128,7 @@ export class SinglyLinkedList extends IterableElementBase {
         const value = this.tail.value;
         current.next = undefined;
         this._tail = current;
-        this._length--;
+        this._size--;
         return value;
     }
     /**
@@ -169,7 +163,7 @@ export class SinglyLinkedList extends IterableElementBase {
             return undefined;
         const removedNode = this.head;
         this._head = this.head.next;
-        this._length--;
+        this._size--;
         return removedNode.value;
     }
     /**
@@ -208,7 +202,8 @@ export class SinglyLinkedList extends IterableElementBase {
             newNode.next = this.head;
             this._head = newNode;
         }
-        this._length++;
+        this._size++;
+        return true;
     }
     /**
      * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
@@ -223,7 +218,7 @@ export class SinglyLinkedList extends IterableElementBase {
      * linked list.
      */
     addFirst(value) {
-        this.unshift(value);
+        return this.unshift(value);
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
@@ -240,7 +235,7 @@ export class SinglyLinkedList extends IterableElementBase {
      * `undefined` if the index is out of bounds.
      */
     getAt(index) {
-        if (index < 0 || index >= this.length)
+        if (index < 0 || index >= this.size)
             return undefined;
         let current = this.head;
         for (let i = 0; i < index; i++) {
@@ -284,17 +279,21 @@ export class SinglyLinkedList extends IterableElementBase {
      * bounds.
      */
     deleteAt(index) {
-        if (index < 0 || index >= this.length)
-            return undefined;
-        if (index === 0)
-            return this.shift();
-        if (index === this.length - 1)
-            return this.pop();
+        if (index < 0 || index >= this.size)
+            return false;
+        if (index === 0) {
+            this.shift();
+            return true;
+        }
+        if (index === this.size - 1) {
+            this.pop();
+            return true;
+        }
         const prevNode = this.getNodeAt(index - 1);
         const removedNode = prevNode.next;
         prevNode.next = removedNode.next;
-        this._length--;
-        return removedNode.value;
+        this._size--;
+        return true;
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
@@ -335,7 +334,7 @@ export class SinglyLinkedList extends IterableElementBase {
                         this._tail = prev;
                     }
                 }
-                this._length--;
+                this._size--;
                 return true;
             }
             prev = current;
@@ -351,7 +350,7 @@ export class SinglyLinkedList extends IterableElementBase {
      * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `insertAt` function inserts a value at a specified index in a singly linked list.
+     * The `addAt` function inserts a value at a specified index in a singly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
      * linked list. It is of type number.
      * @param {E} value - The `value` parameter represents the value that you want to insert into the linked list at the
@@ -359,14 +358,14 @@ export class SinglyLinkedList extends IterableElementBase {
      * @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, value) {
-        if (index < 0 || index > this.length)
+    addAt(index, value) {
+        if (index < 0 || index > this.size)
             return false;
         if (index === 0) {
             this.unshift(value);
             return true;
         }
-        if (index === this.length) {
+        if (index === this.size) {
             this.push(value);
             return true;
         }
@@ -374,7 +373,7 @@ export class SinglyLinkedList extends IterableElementBase {
         const prevNode = this.getNodeAt(index - 1);
         newNode.next = prevNode.next;
         prevNode.next = newNode;
-        this._length++;
+        this._size++;
         return true;
     }
     /**
@@ -383,7 +382,7 @@ export class SinglyLinkedList extends IterableElementBase {
      * @returns A boolean value indicating whether the length of the object is equal to 0.
      */
     isEmpty() {
-        return this.length === 0;
+        return this.size === 0;
     }
     /**
      * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
@@ -391,7 +390,7 @@ export class SinglyLinkedList extends IterableElementBase {
     clear() {
         this._head = undefined;
         this._tail = undefined;
-        this._length = 0;
+        this._size = 0;
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to traverse the entire list to convert it to an array.
@@ -426,7 +425,7 @@ export class SinglyLinkedList extends IterableElementBase {
      */
     reverse() {
         if (!this.head || this.head === this.tail)
-            return;
+            return this;
         let prev = undefined;
         let current = this.head;
         let next = undefined;
@@ -437,6 +436,7 @@ export class SinglyLinkedList extends IterableElementBase {
             current = next;
         }
         [this._head, this._tail] = [this.tail, this.head];
+        return this;
     }
     /**
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
@@ -519,14 +519,14 @@ export class SinglyLinkedList extends IterableElementBase {
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `insertBefore` function inserts a new value before an existing value in a singly linked list.
+     * The `addBefore` function inserts a new value before an existing value in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
      * new value before. It can be either the value itself or a node containing the value in the linked list.
      * @param {E} newValue - The `newValue` parameter represents the value that you want to insert into the linked list.
-     * @returns The method `insertBefore` returns a boolean value. It returns `true` if the new value was successfully
+     * @returns The method `addBefore` returns a boolean value. It returns `true` if the new value was successfully
      * inserted before the existing value, and `false` otherwise.
      */
-    insertBefore(existingValueOrNode, newValue) {
+    addBefore(existingValueOrNode, newValue) {
         if (!this.head)
             return false;
         let existingValue;
@@ -546,7 +546,7 @@ export class SinglyLinkedList extends IterableElementBase {
                 const newNode = new SinglyLinkedListNode(newValue);
                 newNode.next = current.next;
                 current.next = newNode;
-                this._length++;
+                this._size++;
                 return true;
             }
             current = current.next;
@@ -561,14 +561,14 @@ export class SinglyLinkedList extends IterableElementBase {
      * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
      * Space Complexity: O(1) - Constant space.
      *
-     * The `insertAfter` function inserts a new node with a given value after an existing node in a singly linked list.
+     * The `addAfter` function inserts a new node with a given value after an existing node in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node in the 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.
      * @param {E} newValue - The value that you want to insert into the linked list after the existing value or node.
      * @returns The method returns a boolean value. It returns true if the new value was successfully inserted after the
      * existing value or node, and false if the existing value or node was not found in the linked list.
      */
-    insertAfter(existingValueOrNode, newValue) {
+    addAfter(existingValueOrNode, newValue) {
         let existingNode;
         if (existingValueOrNode instanceof SinglyLinkedListNode) {
             existingNode = existingValueOrNode;
@@ -583,7 +583,7 @@ export class SinglyLinkedList extends IterableElementBase {
             if (existingNode === this.tail) {
                 this._tail = newNode;
             }
-            this._length++;
+            this._size++;
             return true;
         }
         return false;
@@ -670,13 +670,6 @@ export class SinglyLinkedList extends IterableElementBase {
         }
         return mappedList;
     }
-    /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
-     * Space Complexity: O(n)
-     */
-    print() {
-        console.log([...this]);
-    }
     *_getIterator() {
         let current = this.head;
         while (current) {

package/dist/mjs/data-structures/linked-list/skip-linked-list.d.ts

@@ -90,7 +90,7 @@ export declare class SkipList<K, V> {
      * Get the value of the first element (the smallest element) in the Skip List.
      * @returns The value of the first element, or undefined if the Skip List is empty.
      */
-    getFirst(): V | undefined;
+    get first(): V | undefined;
     /**
      * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
      * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
@@ -102,7 +102,7 @@ export declare class SkipList<K, V> {
      * Get the value of the last element (the largest element) in the Skip List.
      * @returns The value of the last element, or undefined if the Skip List is empty.
      */
-    getLast(): V | undefined;
+    get last(): V | undefined;
     /**
      * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
      * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.

package/dist/mjs/data-structures/linked-list/skip-linked-list.js

@@ -161,7 +161,7 @@ export class SkipList {
      * Get the value of the first element (the smallest element) in the Skip List.
      * @returns The value of the first element, or undefined if the Skip List is empty.
      */
-    getFirst() {
+    get first() {
         const firstNode = this.head.forward[0];
         return firstNode ? firstNode.value : undefined;
     }
@@ -176,7 +176,7 @@ export class SkipList {
      * Get the value of the last element (the largest element) in the Skip List.
      * @returns The value of the last element, or undefined if the Skip List is empty.
      */
-    getLast() {
+    get last() {
         let current = this.head;
         for (let i = this.level - 1; i >= 0; i--) {
             while (current.forward[i]) {

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import { PriorityQueue } from './priority-queue';
 import type { PriorityQueueOptions } from '../../types';
+import { PriorityQueue } from './priority-queue';
 export declare class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
     constructor(elements?: Iterable<E>, options?: PriorityQueueOptions<E>);
 }

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

@@ -1,10 +1,3 @@
-/**
- * data-structure-typed
- *
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
- * @license MIT License
- */
 import { PriorityQueue } from './priority-queue';
 export class MaxPriorityQueue extends PriorityQueue {
     constructor(elements, options = {

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

@@ -5,8 +5,8 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
-import { PriorityQueue } from './priority-queue';
 import type { PriorityQueueOptions } from '../../types';
+import { PriorityQueue } from './priority-queue';
 export declare class MinPriorityQueue<E = any> extends PriorityQueue<E> {
     constructor(elements?: Iterable<E>, options?: PriorityQueueOptions<E>);
 }

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

@@ -1,10 +1,3 @@
-/**
- * data-structure-typed
- *
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
- * @license MIT License
- */
 import { PriorityQueue } from './priority-queue';
 export class MinPriorityQueue extends PriorityQueue {
     constructor(elements, options = {

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

@@ -5,8 +5,16 @@
  * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
  * @license MIT License
  */
+import type { PriorityQueueOptions } from '../../types';
 import { Heap } from '../heap';
-import { PriorityQueueOptions } from '../../types';
+/**
+ * 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
+ */
 export declare class PriorityQueue<E = any> extends Heap<E> {
     constructor(elements?: Iterable<E>, options?: PriorityQueueOptions<E>);
 }

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

@@ -1,11 +1,12 @@
+import { Heap } from '../heap';
 /**
- * data-structure-typed
- *
- * @author Kirk Qi
- * @copyright Copyright (c) 2022 Kirk Qi <qilinaus@gmail.com>
- * @license MIT License
+ * 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
  */
-import { Heap } from '../heap';
 export class PriorityQueue extends Heap {
     constructor(elements, options) {
         super(elements, options);

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

@@ -5,13 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { ElementCallback, IterableWithSizeOrLength } from "../../types";
+import type { ElementCallback, IterableWithSizeOrLength } from "../../types";
 import { IterableElementBase } from "../base";
 /**
- * Deque can provide random access with O(1) time complexity
- * Deque is usually more compact and efficient in memory usage because it does not require additional space to store pointers.
- * Deque may experience performance jitter, but DoublyLinkedList will not
- * Deque is implemented using a dynamic array. Inserting or deleting beyond both ends of the array may require moving elements or reallocating space.
+ * 1. Operations at Both Ends: Supports adding and removing elements at both the front and back of the queue. This allows it to be used as a stack (last in, first out) and a queue (first in, first out).
+ * 2. Efficient Random Access: Being based on an array, it offers fast random access capability, allowing constant time access to any element.
+ * 3. Continuous Memory Allocation: Since it is based on an array, all elements are stored contiguously in memory, which can bring cache friendliness and efficient memory access.
+ * 4. Efficiency: Adding and removing elements at both ends of a deque is usually very fast. However, when the dynamic array needs to expand, it may involve copying the entire array to a larger one, and this operation has a time complexity of O(n).
+ * 5. Performance jitter: Deque may experience performance jitter, but DoublyLinkedList will not
  */
 export declare class Deque<E> extends IterableElementBase<E> {
     protected _bucketFirst: number;
@@ -41,68 +42,6 @@ export declare class Deque<E> extends IterableElementBase<E> {
      */
     get first(): E | undefined;
     get last(): E | undefined;
-    /**
-     * Time Complexity: O(1) - Removes the last element.
-     * Space Complexity: O(1) - Operates in-place.
-     */
-    isEmpty(): boolean;
-    /**
-     * Time Complexity: Amortized O(1) - Similar to push, resizing leads to O(n).
-     * Space Complexity: O(n) - Due to potential resizing.
-     */
-    /**
-     * Time Complexity: O(1)
-     * Space Complexity: O(n) - In worst case, resizing doubles the array size.
-     *
-     * The addLast function adds an element to the end of an array.
-     * @param {E} element - The element parameter represents the element that you want to add to the end of the
-     * data structure.
-     */
-    addLast(element: E): void;
-    /**
-     * Time Complexity: O(1) - Removes the first element.
-     * Space Complexity: O(1) - In-place operation.
-     */
-    /**
-     * Time Complexity: O(1) - Removes the last element.
-     * Space Complexity: O(1) - Operates in-place.
-     *
-     * The function "pollLast" removes and returns the last element of an array.
-     * @returns The last element of the array is being returned.
-     */
-    pollLast(): E | undefined;
-    /**
-     * Time Complexity: O(1).
-     * Space Complexity: O(n) - Due to potential resizing.
-     *
-     * The "addFirst" function adds an element to the beginning of an array.
-     * @param {E} element - The parameter "element" represents the element that you want to add to the
-     * beginning of the data structure.
-     */
-    addFirst(element: E): void;
-    /**
-     * Time Complexity: O(1) - Removes the first element.
-     * Space Complexity: O(1) - In-place operation.
-     *
-     * The function "pollFirst" removes and returns the first element of an array.
-     * @returns The method `pollFirst()` is returning the first element of the array after removing it
-     * from the beginning. If the array is empty, it will return `undefined`.
-     */
-    pollFirst(): E | undefined;
-    /**
-     * The clear() function resets the state of the object by initializing all variables to their default
-     * values.
-     */
-    clear(): void;
-    /**
-     * The below function is a generator that yields elements from a collection one by one.
-     */
-    begin(): Generator<E>;
-    /**
-     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
-     * the last element.
-     */
-    reverseBegin(): Generator<E>;
     /**
      * Time Complexity - Amortized O(1) (possible reallocation)
      * Space Complexity - O(n) (due to potential resizing).
@@ -116,7 +55,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * structure.
      * @returns The size of the data structure after the element has been pushed.
      */
-    push(element: E): number;
+    push(element: E): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -144,7 +83,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * beginning of the data structure.
      * @returns The size of the data structure after the element has been added.
      */
-    unshift(element: E): number;
+    unshift(element: E): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -159,6 +98,25 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * returned.
      */
     shift(): E | undefined;
+    /**
+     * Time Complexity: O(1) - Removes the last element.
+     * Space Complexity: O(1) - Operates in-place.
+     */
+    isEmpty(): boolean;
+    /**
+     * The clear() function resets the state of the object by initializing all variables to their default
+     * values.
+     */
+    clear(): void;
+    /**
+     * The below function is a generator that yields elements from a collection one by one.
+     */
+    begin(): Generator<E>;
+    /**
+     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
+     * the last element.
+     */
+    reverseBegin(): Generator<E>;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -188,7 +146,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * @param {E} element - The `element` parameter is the value that you want to set at the specified
      * position in the data structure.
      */
-    setAt(pos: number, element: E): void;
+    setAt(pos: number, element: E): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -197,7 +155,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      *
-     * The `insertAt` function inserts one or more elements at a specified position in an array-like data
+     * The `addAt` function inserts one or more elements at a specified position in an array-like data
      * structure.
      * @param {number} pos - The `pos` parameter represents the position at which the element(s) should
      * be inserted. It is of type `number`.
@@ -208,7 +166,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * will be inserted once. However, you can provide a different value for `num` if you want
      * @returns The size of the array after the insertion is being returned.
      */
-    insertAt(pos: number, element: E, num?: number): number;
+    addAt(pos: number, element: E, num?: number): boolean;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -239,7 +197,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * the index of the element to be deleted.
      * @returns The size of the data structure after the deletion operation is performed.
      */
-    deleteAt(pos: number): number;
+    deleteAt(pos: number): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -254,7 +212,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * the data structure.
      * @returns The size of the data structure after the element has been deleted.
      */
-    delete(element: E): number;
+    delete(element: E): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -281,7 +239,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * the number of unique elements.
      * @returns The size of the modified array is being returned.
      */
-    unique(): number;
+    unique(): this;
     /**
      * Time Complexity: O(n log n)
      * Space Complexity: O(n)
@@ -294,7 +252,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * @param [comparator] - The `comparator` parameter is a function that takes in two elements `x` and
      * `y` of type `E` and returns a number. The comparator function is used to determine the order of
      * the elements in the sorted array.
-     * @returns The method is returning the sorted instance of the object on which the method is called.
+     * @returns Deque<E>
      */
     sort(comparator?: (x: E, y: E) => number): this;
     /**
@@ -395,10 +353,48 @@ export declare class Deque<E> extends IterableElementBase<E> {
      */
     map<T>(callback: ElementCallback<E, T>, thisArg?: any): Deque<T>;
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Time Complexity: Amortized O(1) - Similar to push, resizing leads to O(n).
+     * Space Complexity: O(n) - Due to potential resizing.
+     */
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(n) - In worst case, resizing doubles the array size.
+     *
+     * The addLast function adds an element to the end of an array.
+     * @param {E} element - The element parameter represents the element that you want to add to the end of the
+     * data structure.
+     */
+    addLast(element: E): boolean;
+    /**
+     * Time Complexity: O(1) - Removes the first element.
+     * Space Complexity: O(1) - In-place operation.
+     */
+    /**
+     * Time Complexity: O(1) - Removes the last element.
+     * Space Complexity: O(1) - Operates in-place.
+     *
+     * The function "pollLast" removes and returns the last element of an array.
+     * @returns The last element of the array is being returned.
+     */
+    pollLast(): E | undefined;
+    /**
+     * Time Complexity: O(1).
+     * Space Complexity: O(n) - Due to potential resizing.
+     *
+     * The "addFirst" function adds an element to the beginning of an array.
+     * @param {E} element - The parameter "element" represents the element that you want to add to the
+     * beginning of the data structure.
      */
-    print(): void;
+    addFirst(element: E): boolean;
+    /**
+     * Time Complexity: O(1) - Removes the first element.
+     * Space Complexity: O(1) - In-place operation.
+     *
+     * The function "pollFirst" removes and returns the first element of an array.
+     * @returns The method `pollFirst()` is returning the first element of the array after removing it
+     * from the beginning. If the array is empty, it will return `undefined`.
+     */
+    pollFirst(): E | undefined;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -406,7 +402,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
      * The above function is an implementation of the iterator protocol in TypeScript, allowing the
      * object to be iterated over using a for...of loop.
      */
-    protected _getIterator(): Generator<E, void, unknown>;
+    protected _getIterator(): IterableIterator<E>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)