bst-typed 1.49.0 → 1.49.2

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

@@ -1,20 +1,14 @@
 "use strict";
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Deque = void 0;
-const utils_1 = require("../../utils");
 const base_1 = require("../base");
+const utils_1 = require("../../utils");
 /**
- * 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
  */
 class Deque extends base_1.IterableElementBase {
     /**
@@ -81,95 +75,6 @@ class Deque extends base_1.IterableElementBase {
             return;
         return this._buckets[this._bucketLast][this._lastInBucket];
     }
-    /**
-     * Time Complexity: O(1) - Removes the last element.
-     * Space Complexity: O(1) - Operates in-place.
-     */
-    isEmpty() {
-        return this.size === 0;
-    }
-    /**
-     * 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) {
-        this.push(element);
-    }
-    /**
-     * 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() {
-        return this.pop();
-    }
-    /**
-     * 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) {
-        this.unshift(element);
-    }
-    /**
-     * 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() {
-        return this.shift();
-    }
-    /**
-     * The clear() function resets the state of the object by initializing all variables to their default
-     * values.
-     */
-    clear() {
-        this._buckets = [new Array(this._bucketSize)];
-        this._bucketCount = 1;
-        this._bucketFirst = this._bucketLast = this._size = 0;
-        this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
-    }
-    /**
-     * The below function is a generator that yields elements from a collection one by one.
-     */
-    *begin() {
-        let index = 0;
-        while (index < this.size) {
-            yield this.getAt(index);
-            index++;
-        }
-    }
-    /**
-     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
-     * the last element.
-     */
-    *reverseBegin() {
-        let index = this.size - 1;
-        while (index >= 0) {
-            yield this.getAt(index);
-            index--;
-        }
-    }
     /**
      * Time Complexity - Amortized O(1) (possible reallocation)
      * Space Complexity - O(n) (due to potential resizing).
@@ -202,7 +107,7 @@ class Deque extends base_1.IterableElementBase {
         }
         this._size += 1;
         this._buckets[this._bucketLast][this._lastInBucket] = element;
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(1)
@@ -269,7 +174,7 @@ class Deque extends base_1.IterableElementBase {
         }
         this._size += 1;
         this._buckets[this._bucketFirst][this._firstInBucket] = element;
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(1)
@@ -304,6 +209,44 @@ class Deque extends base_1.IterableElementBase {
         this._size -= 1;
         return element;
     }
+    /**
+     * Time Complexity: O(1) - Removes the last element.
+     * Space Complexity: O(1) - Operates in-place.
+     */
+    isEmpty() {
+        return this.size === 0;
+    }
+    /**
+     * The clear() function resets the state of the object by initializing all variables to their default
+     * values.
+     */
+    clear() {
+        this._buckets = [new Array(this._bucketSize)];
+        this._bucketCount = 1;
+        this._bucketFirst = this._bucketLast = this._size = 0;
+        this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
+    }
+    /**
+     * The below function is a generator that yields elements from a collection one by one.
+     */
+    *begin() {
+        let index = 0;
+        while (index < this.size) {
+            yield this.getAt(index);
+            index++;
+        }
+    }
+    /**
+     * The function `reverseBegin()` is a generator that yields elements in reverse order starting from
+     * the last element.
+     */
+    *reverseBegin() {
+        let index = this.size - 1;
+        while (index >= 0) {
+            yield this.getAt(index);
+            index--;
+        }
+    }
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -341,6 +284,7 @@ class Deque extends base_1.IterableElementBase {
         (0, utils_1.rangeCheck)(pos, 0, this.size - 1);
         const { bucketIndex, indexInBucket } = this._getBucketAndPosition(pos);
         this._buckets[bucketIndex][indexInBucket] = element;
+        return true;
     }
     /**
      * Time Complexity: O(n)
@@ -350,7 +294,7 @@ class Deque extends base_1.IterableElementBase {
      * 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`.
@@ -361,7 +305,7 @@ class Deque extends base_1.IterableElementBase {
      * 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, element, num = 1) {
+    addAt(pos, element, num = 1) {
         const length = this.size;
         (0, utils_1.rangeCheck)(pos, 0, length);
         if (pos === 0) {
@@ -383,7 +327,7 @@ class Deque extends base_1.IterableElementBase {
             for (let i = 0; i < arr.length; ++i)
                 this.push(arr[i]);
         }
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(1)
@@ -442,7 +386,7 @@ class Deque extends base_1.IterableElementBase {
             }
             this.pop();
         }
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(n)
@@ -461,7 +405,7 @@ class Deque extends base_1.IterableElementBase {
     delete(element) {
         const size = this.size;
         if (size === 0)
-            return 0;
+            return false;
         let i = 0;
         let index = 0;
         while (i < size) {
@@ -473,7 +417,7 @@ class Deque extends base_1.IterableElementBase {
             i += 1;
         }
         this.cut(index - 1);
-        return this.size;
+        return true;
     }
     /**
      * Time Complexity: O(n)
@@ -513,7 +457,7 @@ class Deque extends base_1.IterableElementBase {
      */
     unique() {
         if (this.size <= 1) {
-            return this.size;
+            return this;
         }
         let index = 1;
         let prev = this.getAt(0);
@@ -525,7 +469,7 @@ class Deque extends base_1.IterableElementBase {
             }
         }
         this.cut(index - 1);
-        return this.size;
+        return this;
     }
     /**
      * Time Complexity: O(n log n)
@@ -539,7 +483,7 @@ class Deque extends base_1.IterableElementBase {
      * @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) {
         const arr = [];
@@ -610,7 +554,7 @@ class Deque extends base_1.IterableElementBase {
                 return element;
             }
         }
-        return undefined;
+        return;
     }
     /**
      * Time Complexity: O(n)
@@ -647,11 +591,7 @@ class Deque extends base_1.IterableElementBase {
      * @returns The `toArray()` method is returning an array of elements of type `E`.
      */
     toArray() {
-        const arr = [];
-        for (let i = 0; i < this.size; ++i) {
-            arr.push(this.getAt(i));
-        }
-        return arr;
+        return [...this];
     }
     /**
      * Time Complexity: O(n)
@@ -711,11 +651,55 @@ class Deque extends base_1.IterableElementBase {
         return newDeque;
     }
     /**
-     * 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) {
+        return this.push(element);
+    }
+    /**
+     * 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.
      */
-    print() {
-        console.log([...this]);
+    pollLast() {
+        return this.pop();
+    }
+    /**
+     * 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) {
+        return this.unshift(element);
+    }
+    /**
+     * 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() {
+        return this.shift();
     }
     /**
      * Time Complexity: O(n)

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

@@ -3,9 +3,18 @@
  * @copyright Tyler Zeng <zrwusa@gmail.com>
  * @class
  */
-import { SinglyLinkedList } from '../linked-list';
+import type { ElementCallback } from '../../types';
 import { IterableElementBase } from "../base";
-import { ElementCallback } from "../../types";
+import { SinglyLinkedList } from '../linked-list';
+/**
+ * 1. First In, First Out (FIFO): The core feature of a queue is its first in, first out nature. The element added to the queue first will be the one to be removed first.
+ * 2. Operations: The main operations include enqueue (adding an element to the end of the queue) and dequeue (removing and returning the element at the front of the queue). Typically, there is also a peek operation (looking at the front element without removing it).
+ * 3. Uses: Queues are commonly used to manage a series of tasks or elements that need to be processed in order. For example, managing task queues in a multi-threaded environment, or in algorithms for data structures like trees and graphs for breadth-first search.
+ * 4. Task Scheduling: Managing the order of task execution in operating systems or applications.
+ * 5. Data Buffering: Acting as a buffer for data packets in network communication.
+ * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store nodes that are to be visited.
+ * 7. Real-time Queuing: Like queuing systems in banks or supermarkets.
+ */
 export declare class Queue<E = any> extends IterableElementBase<E> {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
@@ -44,7 +53,7 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * @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>;
+    push(element: E): boolean;
     /**
      * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
      * Space Complexity: O(1) - no additional space is used.
@@ -66,11 +75,11 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-     * @returns The `getFirst()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * The `first` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
+     * @returns The `get first()` 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 `undefined`.
      */
-    getFirst(): E | undefined;
+    get first(): E | undefined;
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
@@ -92,11 +101,11 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `getLast` function returns the last element in an array-like data structure, or undefined 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
+     * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
+     * @returns The method `get last()` returns the last element of the `_nodes` array if the array is not empty. If the
      * array is empty, it returns `undefined`.
      */
-    getLast(): E | undefined;
+    get last(): E | undefined;
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
@@ -121,7 +130,7 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * 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;
+    enqueue(value: E): boolean;
     /**
      * Time Complexity: O(n) - same as shift().
      * Space Complexity: O(1) - same as shift().
@@ -185,7 +194,6 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
     clone(): Queue<E>;
-    print(): void;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -230,24 +238,30 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
-    protected _getIterator(): Generator<E, void, unknown>;
+    protected _getIterator(): IterableIterator<E>;
 }
+/**
+ * 1. First In, First Out (FIFO) Strategy: Like other queue implementations, LinkedListQueue follows the first in, first out principle, meaning the element that is added to the queue first will be the first to be removed.
+ * 2. Based on Linked List: LinkedListQueue uses a linked list to store elements. Each node in the linked list contains data and a pointer to the next node.
+ * 3. Memory Usage: Since each element requires additional space to store a pointer to the next element, linked lists may use more memory compared to arrays.
+ * 4. Frequent Enqueuing and Dequeuing Operations: If your application involves frequent enqueuing and dequeuing operations and is less concerned with random access, then LinkedListQueue is a good choice.
+ */
 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;
+    enqueue(value: E): boolean;
     /**
      * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
      * @returns The method is returning the element at the front of the queue, or undefined 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`.
+     * The `get first` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `get first()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
      */
-    getFirst(): E | undefined;
+    get first(): 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`.

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

@@ -1,13 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LinkedListQueue = exports.Queue = void 0;
+const base_1 = require("../base");
+const linked_list_1 = require("../linked-list");
 /**
- * @license MIT
- * @copyright Tyler Zeng <zrwusa@gmail.com>
- * @class
+ * 1. First In, First Out (FIFO): The core feature of a queue is its first in, first out nature. The element added to the queue first will be the one to be removed first.
+ * 2. Operations: The main operations include enqueue (adding an element to the end of the queue) and dequeue (removing and returning the element at the front of the queue). Typically, there is also a peek operation (looking at the front element without removing it).
+ * 3. Uses: Queues are commonly used to manage a series of tasks or elements that need to be processed in order. For example, managing task queues in a multi-threaded environment, or in algorithms for data structures like trees and graphs for breadth-first search.
+ * 4. Task Scheduling: Managing the order of task execution in operating systems or applications.
+ * 5. Data Buffering: Acting as a buffer for data packets in network communication.
+ * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store nodes that are to be visited.
+ * 7. Real-time Queuing: Like queuing systems in banks or supermarkets.
  */
-const linked_list_1 = require("../linked-list");
-const base_1 = require("../base");
 class Queue extends base_1.IterableElementBase {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
@@ -58,7 +62,7 @@ class Queue extends base_1.IterableElementBase {
      */
     push(element) {
         this.nodes.push(element);
-        return this;
+        return true;
     }
     /**
      * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
@@ -75,7 +79,7 @@ class Queue extends base_1.IterableElementBase {
     shift() {
         if (this.size === 0)
             return undefined;
-        const first = this.getFirst();
+        const first = this.first;
         this._offset += 1;
         if (this.offset * 2 < this.nodes.length)
             return first;
@@ -93,11 +97,11 @@ class Queue extends base_1.IterableElementBase {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `getFirst` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-     * @returns The `getFirst()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * The `first` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
+     * @returns The `get first()` 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 `undefined`.
      */
-    getFirst() {
+    get first() {
         return this.size > 0 ? this.nodes[this.offset] : undefined;
     }
     /**
@@ -113,7 +117,7 @@ class Queue extends base_1.IterableElementBase {
      * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     peek() {
-        return this.getFirst();
+        return this.first;
     }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
@@ -123,11 +127,11 @@ class Queue extends base_1.IterableElementBase {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `getLast` function returns the last element in an array-like data structure, or undefined 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
+     * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
+     * @returns The method `get last()` returns the last element of the `_nodes` array if the array is not empty. If the
      * array is empty, it returns `undefined`.
      */
-    getLast() {
+    get last() {
         return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
     }
     /**
@@ -143,7 +147,7 @@ class Queue extends base_1.IterableElementBase {
      * array is empty, it returns `undefined`.
      */
     peekLast() {
-        return this.getLast();
+        return this.last;
     }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
@@ -157,7 +161,7 @@ class Queue extends base_1.IterableElementBase {
      * @param {E} value - The value parameter represents the value that you want to add to the queue.
      */
     enqueue(value) {
-        this.push(value);
+        return this.push(value);
     }
     /**
      * Time Complexity: O(n) - same as shift().
@@ -235,9 +239,6 @@ class Queue extends base_1.IterableElementBase {
     clone() {
         return new Queue(this.nodes.slice(this.offset));
     }
-    print() {
-        console.log([...this]);
-    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -307,13 +308,19 @@ class Queue extends base_1.IterableElementBase {
     }
 }
 exports.Queue = Queue;
+/**
+ * 1. First In, First Out (FIFO) Strategy: Like other queue implementations, LinkedListQueue follows the first in, first out principle, meaning the element that is added to the queue first will be the first to be removed.
+ * 2. Based on Linked List: LinkedListQueue uses a linked list to store elements. Each node in the linked list contains data and a pointer to the next node.
+ * 3. Memory Usage: Since each element requires additional space to store a pointer to the next element, linked lists may use more memory compared to arrays.
+ * 4. Frequent Enqueuing and Dequeuing Operations: If your application involves frequent enqueuing and dequeuing operations and is less concerned with random access, then LinkedListQueue is a good choice.
+ */
 class LinkedListQueue extends linked_list_1.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);
+        return this.push(value);
     }
     /**
      * The `dequeue` function removes and returns the first element from a queue, or returns undefined if the queue is empty.
@@ -323,10 +330,10 @@ class LinkedListQueue extends linked_list_1.SinglyLinkedList {
         return this.shift();
     }
     /**
-     * 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`.
+     * The `get first` function returns the value of the head node in a linked list, or `undefined` if the list is empty.
+     * @returns The `get first()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
      */
-    getFirst() {
+    get first() {
         var _a;
         return (_a = this.head) === null || _a === void 0 ? void 0 : _a.value;
     }
@@ -335,7 +342,7 @@ class LinkedListQueue extends linked_list_1.SinglyLinkedList {
      * @returns The `peek()` method is returning the value of the `head` node if it exists, otherwise it returns `undefined`.
      */
     peek() {
-        return this.getFirst();
+        return this.first;
     }
 }
 exports.LinkedListQueue = LinkedListQueue;

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

@@ -1,9 +1,19 @@
-import { IterableElementBase } from "../base";
-import { ElementCallback } from "../../types";
 /**
- * @license MIT
- * @copyright Tyler Zeng <zrwusa@gmail.com>
- * @class
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+import type { ElementCallback } from '../../types';
+import { IterableElementBase } from '../base';
+/**
+ * 1. Last In, First Out (LIFO): The core characteristic of a stack is its last in, first out nature, meaning the last element added to the stack will be the first to be removed.
+ * 2. Uses: Stacks are commonly used for managing a series of tasks or elements that need to be processed in a last in, first out manner. They are widely used in various scenarios, such as in function calls in programming languages, evaluation of arithmetic expressions, and backtracking algorithms.
+ * 3. Performance: Stack operations are typically O(1) in time complexity, meaning that regardless of the stack's size, adding, removing, and viewing the top element are very fast operations.
+ * 4. Function Calls: In most modern programming languages, the records of function calls are managed through a stack. When a function is called, its record (including parameters, local variables, and return address) is 'pushed' into the stack. When the function returns, its record is 'popped' from the stack.
+ * 5. Expression Evaluation: Used for the evaluation of arithmetic or logical expressions, especially when dealing with parenthesis matching and operator precedence.
+ * 6. Backtracking Algorithms: In problems where multiple branches need to be explored but only one branch can be explored at a time, stacks can be used to save the state at each branching point.
  */
 export declare class Stack<E = any> extends IterableElementBase<E> {
     /**
@@ -63,7 +73,7 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      * @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>;
+    push(element: E): boolean;
     /**
      * Time Complexity: O(1), as it only involves accessing the last element of the array.
      * Space Complexity: O(1), as it does not use any additional space.
@@ -144,10 +154,9 @@ export declare class Stack<E = any> extends IterableElementBase<E> {
      * @returns The `map` method is returning a new `Stack` object.
      */
     map<T>(callback: ElementCallback<E, T>, thisArg?: any): Stack<T>;
-    print(): void;
     /**
      * Custom iterator for the Stack class.
      * @returns An iterator object.
      */
-    protected _getIterator(): Generator<E, void, unknown>;
+    protected _getIterator(): IterableIterator<E>;
 }