min-heap-typed 1.49.2 → 1.49.4

package/dist/data-structures/binary-tree/binary-tree.d.ts

@@ -525,7 +525,7 @@ export declare class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V,
     print(beginRoot?: BTNKeyOrNode<K, N>, options?: BinaryTreePrintOptions): void;
     protected _getIterator(node?: N | null | undefined): IterableIterator<[K, V | undefined]>;
     protected _displayAux(node: N | null | undefined, options: BinaryTreePrintOptions): NodeDisplayLayout;
-    protected _defaultOneParamCallback: (node: N) => K;
+    protected _defaultOneParamCallback: (node: N | null | undefined) => K | undefined;
     /**
      * Swap the data of two nodes in the binary tree.
      * @param {N} srcNode - The source node to swap.

package/dist/data-structures/binary-tree/binary-tree.js

@@ -80,7 +80,7 @@ class BinaryTree extends base_1.IterableEntryBase {
         super();
         this.iterationType = types_1.IterationType.ITERATIVE;
         this._extractor = (key) => Number(key);
-        this._defaultOneParamCallback = (node) => node.key;
+        this._defaultOneParamCallback = (node) => node ? node.key : undefined;
         if (options) {
             const { iterationType, extractor } = options;
             if (iterationType) {

package/dist/data-structures/graph/abstract-graph.d.ts

@@ -99,16 +99,7 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * Time Complexity: O(1) - Constant time for Map operations.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
      */
-    /**
-     * Time Complexity: O(1) - Constant time for Map operations.
-     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-     *
-     * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
-     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
-     * (`VertexKey`).
-     * @returns The method is returning a boolean value.
-     */
-    deleteVertex(vertexOrKey: VO | VertexKey): boolean;
+    abstract deleteVertex(vertexOrKey: VO | VertexKey): boolean;
     /**
      * Time Complexity: O(K), where K is the number of vertexMap to be removed.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -432,11 +423,6 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * type `number`.
      */
     getLowMap(): Map<VO, number>;
-    /**
-     * The function `getCycles` returns a map of cycles found using the Tarjan algorithm.
-     * @returns The function `getCycles()` is returning a `Map<number, VO[]>`.
-     */
-    getCycles(): Map<number, VO[]>;
     /**
      * The function "getCutVertexes" returns an array of cut vertexes using the Tarjan algorithm.
      * @returns an array of VO objects, specifically the cut vertexes.
@@ -453,6 +439,11 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      * @returns the bridges found using the Tarjan algorithm.
      */
     getBridges(): EO[];
+    /**
+     * O(V+E+C)
+     * O(V+C)
+     */
+    getCycles(isInclude2Cycle?: boolean): VertexKey[][];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -493,8 +484,8 @@ export declare abstract class AbstractGraph<V = any, E = any, VO extends Abstrac
      */
     map<T>(callback: EntryCallback<VertexKey, V | undefined, T>, thisArg?: any): T[];
     protected _getIterator(): IterableIterator<[VertexKey, V | undefined]>;
-    protected abstract _addEdgeOnly(edge: EO): boolean;
-    protected _addVertexOnly(newVertex: VO): boolean;
+    protected abstract _addEdge(edge: EO): boolean;
+    protected _addVertex(newVertex: VO): boolean;
     protected _getVertex(vertexOrKey: VertexKey | VO): VO | undefined;
     protected _getVertexKey(vertexOrKey: VO | VertexKey): VertexKey;
 }

package/dist/data-structures/graph/abstract-graph.js

@@ -86,34 +86,17 @@ class AbstractGraph extends base_1.IterableEntryBase {
      */
     addVertex(keyOrVertex, value) {
         if (keyOrVertex instanceof AbstractVertex) {
-            return this._addVertexOnly(keyOrVertex);
+            return this._addVertex(keyOrVertex);
         }
         else {
             const newVertex = this.createVertex(keyOrVertex, value);
-            return this._addVertexOnly(newVertex);
+            return this._addVertex(newVertex);
         }
     }
     isVertexKey(potentialKey) {
         const potentialKeyType = typeof potentialKey;
         return potentialKeyType === "string" || potentialKeyType === "number";
     }
-    /**
-     * Time Complexity: O(1) - Constant time for Map operations.
-     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-     */
-    /**
-     * Time Complexity: O(1) - Constant time for Map operations.
-     * Space Complexity: O(1) - Constant space, as it creates only a few variables.
-     *
-     * The `deleteVertex` function removes a vertex from a graph by its ID or by the vertex object itself.
-     * @param {VO | VertexKey} vertexOrKey - The parameter `vertexOrKey` can be either a vertex object (`VO`) or a vertex ID
-     * (`VertexKey`).
-     * @returns The method is returning a boolean value.
-     */
-    deleteVertex(vertexOrKey) {
-        const vertexKey = this._getVertexKey(vertexOrKey);
-        return this._vertexMap.delete(vertexKey);
-    }
     /**
      * Time Complexity: O(K), where K is the number of vertexMap to be removed.
      * Space Complexity: O(1) - Constant space, as it creates only a few variables.
@@ -160,7 +143,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
      */
     addEdge(srcOrEdge, dest, weight, value) {
         if (srcOrEdge instanceof AbstractEdge) {
-            return this._addEdgeOnly(srcOrEdge);
+            return this._addEdge(srcOrEdge);
         }
         else {
             if (dest instanceof AbstractVertex || typeof dest === 'string' || typeof dest === 'number') {
@@ -171,7 +154,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
                 if (dest instanceof AbstractVertex)
                     dest = dest.key;
                 const newEdge = this.createEdge(srcOrEdge, dest, weight, value);
-                return this._addEdgeOnly(newEdge);
+                return this._addEdge(newEdge);
             }
             else {
                 throw new Error('dest must be a Vertex or vertex key while srcOrEdge is an Edge');
@@ -1001,13 +984,6 @@ class AbstractGraph extends base_1.IterableEntryBase {
     getLowMap() {
         return this.tarjan(false, false, false, false).lowMap;
     }
-    /**
-     * The function `getCycles` returns a map of cycles found using the Tarjan algorithm.
-     * @returns The function `getCycles()` is returning a `Map<number, VO[]>`.
-     */
-    getCycles() {
-        return this.tarjan(false, false, false, true).cycles;
-    }
     /**
      * The function "getCutVertexes" returns an array of cut vertexes using the Tarjan algorithm.
      * @returns an array of VO objects, specifically the cut vertexes.
@@ -1030,6 +1006,44 @@ class AbstractGraph extends base_1.IterableEntryBase {
     getBridges() {
         return this.tarjan(false, true, false, false).bridges;
     }
+    /**
+     * O(V+E+C)
+     * O(V+C)
+     */
+    getCycles(isInclude2Cycle = false) {
+        const cycles = [];
+        const visited = new Set();
+        const dfs = (vertex, currentPath, visited) => {
+            if (visited.has(vertex)) {
+                if ((!isInclude2Cycle && currentPath.length > 2 || isInclude2Cycle && currentPath.length >= 2) && currentPath[0] === vertex.key) {
+                    cycles.push([...currentPath]);
+                }
+                return;
+            }
+            visited.add(vertex);
+            currentPath.push(vertex.key);
+            for (const neighbor of this.getNeighbors(vertex)) {
+                neighbor && dfs(neighbor, currentPath, visited);
+            }
+            visited.delete(vertex);
+            currentPath.pop();
+        };
+        for (const vertex of this.vertexMap.values()) {
+            dfs(vertex, [], visited);
+        }
+        // Use a set to eliminate duplicate cycles
+        const uniqueCycles = new Map();
+        for (const cycle of cycles) {
+            const sorted = [...cycle].sort().toString();
+            if (uniqueCycles.has(sorted))
+                continue;
+            else {
+                uniqueCycles.set(sorted, cycle);
+            }
+        }
+        // Convert the unique cycles back to an array
+        return [...uniqueCycles].map(cycleString => cycleString[1]);
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -1092,7 +1106,7 @@ class AbstractGraph extends base_1.IterableEntryBase {
             yield [vertex.key, vertex.value];
         }
     }
-    _addVertexOnly(newVertex) {
+    _addVertex(newVertex) {
         if (this.hasVertex(newVertex)) {
             return false;
             // throw (new Error('Duplicated vertex key is not allowed'));

package/dist/data-structures/graph/directed-graph.d.ts

@@ -335,11 +335,11 @@ export declare class DirectedGraph<V = any, E = any, VO extends DirectedVertex<V
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `_addEdgeOnly` adds an edge to a graph if the source and destination vertexMap exist.
+     * The function `_addEdge` adds an edge to a graph if the source and destination vertexMap exist.
      * @param {EO} edge - The parameter `edge` is of type `EO`, which represents an edge in a graph. It is the edge that
      * needs to be added to the graph.
      * @returns a boolean value. It returns true if the edge was successfully added to the graph, and false if either the
      * source or destination vertex does not exist in the graph.
      */
-    protected _addEdgeOnly(edge: EO): boolean;
+    protected _addEdge(edge: EO): boolean;
 }

package/dist/data-structures/graph/directed-graph.js

@@ -212,6 +212,10 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
             vertexKey = this._getVertexKey(vertexOrKey);
         }
         if (vertex) {
+            const neighbors = this.getNeighbors(vertex);
+            for (const neighbor of neighbors) {
+                this._inEdgeMap.delete(neighbor);
+            }
             this._outEdgeMap.delete(vertex);
             this._inEdgeMap.delete(vertex);
         }
@@ -531,13 +535,13 @@ class DirectedGraph extends abstract_graph_1.AbstractGraph {
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function `_addEdgeOnly` adds an edge to a graph if the source and destination vertexMap exist.
+     * The function `_addEdge` adds an edge to a graph if the source and destination vertexMap exist.
      * @param {EO} edge - The parameter `edge` is of type `EO`, which represents an edge in a graph. It is the edge that
      * needs to be added to the graph.
      * @returns a boolean value. It returns true if the edge was successfully added to the graph, and false if either the
      * source or destination vertex does not exist in the graph.
      */
-    _addEdgeOnly(edge) {
+    _addEdge(edge) {
         if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
             return false;
         }

package/dist/data-structures/graph/undirected-graph.d.ts

@@ -205,5 +205,5 @@ export declare class UndirectedGraph<V = any, E = any, VO extends UndirectedVert
      * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
      * @returns a boolean value.
      */
-    protected _addEdgeOnly(edge: EO): boolean;
+    protected _addEdge(edge: EO): boolean;
 }

package/dist/data-structures/graph/undirected-graph.js

@@ -337,7 +337,7 @@ class UndirectedGraph extends abstract_graph_1.AbstractGraph {
      * @param {EO} edge - The parameter "edge" is of type EO, which represents an edge in a graph.
      * @returns a boolean value.
      */
-    _addEdgeOnly(edge) {
+    _addEdge(edge) {
         for (const end of edge.vertexMap) {
             const endVertex = this._getVertex(end);
             if (endVertex === undefined)

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

@@ -39,6 +39,30 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * 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 number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * 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.
+     */
+    get first(): E | undefined;
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * 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.
+     */
+    get last(): E | undefined;
+    /**
+     * 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)
@@ -75,7 +99,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     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)
      */
     /**
@@ -88,7 +112,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     shift(): 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)
      */
     /**
@@ -198,10 +222,6 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * existing value or node is not found in the doubly linked list.
      */
     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)
-     */
     /**
      * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
@@ -213,10 +233,6 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * bounds.
      */
     deleteAt(index: number): boolean;
-    /**
-     * 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)
@@ -228,11 +244,19 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * deleted from the doubly linked list, and `false` if the value or node was not found in the list.
      */
     delete(valOrNode: E | DoublyLinkedListNode<E> | undefined): boolean;
+    /**
+     * 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;
+    /**
+     * 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.
      */
@@ -269,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.
@@ -285,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.
@@ -295,7 +319,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     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)
      */
     /**
@@ -319,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)
@@ -341,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)
@@ -388,7 +412,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     pollLast(): 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)
      */
     /**
@@ -401,7 +425,7 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      */
     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)
      */
     /**
@@ -413,30 +437,6 @@ export declare class DoublyLinkedList<E = any> extends IterableElementBase<E> {
      * 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 `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.
-     */
-    get first(): 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 `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.
-     */
-    get last(): E | undefined;
     /**
      * The function returns an iterator that iterates over the values of a linked list.
      */

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -49,6 +49,36 @@ class DoublyLinkedList extends base_1.IterableElementBase {
      * 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 number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * 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.
+     */
+    get first() {
+        var _a;
+        return (_a = this.head) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    /**
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
+     */
+    /**
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Space Complexity: O(1)
+     *
+     * 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.
+     */
+    get last() {
+        var _a;
+        return (_a = this.tail) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    /**
+     * 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)
@@ -118,7 +148,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return removedNode.value;
     }
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      */
     /**
@@ -145,7 +175,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return removedNode.value;
     }
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      */
     /**
@@ -359,10 +389,6 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         }
         return false;
     }
-    /**
-     * 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)
@@ -392,10 +418,6 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         this._size--;
         return true;
     }
-    /**
-     * 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)
@@ -432,6 +454,10 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         }
         return false;
     }
+    /**
+     * 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.
@@ -439,6 +465,10 @@ class DoublyLinkedList extends base_1.IterableElementBase {
     isEmpty() {
         return this.size === 0;
     }
+    /**
+     * 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.
      */
@@ -499,7 +529,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
     }
     /**
      * 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.
@@ -524,7 +554,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
     }
     /**
      * 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.
@@ -543,7 +573,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return this;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
@@ -583,8 +613,8 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return array;
     }
     /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(n)
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
      * Time Complexity: O(n)
@@ -615,8 +645,8 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return filteredList;
     }
     /**
-     * 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)
@@ -674,7 +704,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return this.pop();
     }
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      */
     /**
@@ -689,7 +719,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
         return this.shift();
     }
     /**
-     * Time Complexity: O(1)
+     * Time Complexity: O(n), where n is the number of elements in the linked list.
      * Space Complexity: O(1)
      */
     /**
@@ -703,36 +733,6 @@ class DoublyLinkedList extends base_1.IterableElementBase {
     addFirst(value) {
         this.unshift(value);
     }
-    /**
-     * 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 `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.
-     */
-    get first() {
-        var _a;
-        return (_a = this.head) === null || _a === void 0 ? void 0 : _a.value;
-    }
-    /**
-     * 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 `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.
-     */
-    get last() {
-        var _a;
-        return (_a = this.tail) === null || _a === void 0 ? void 0 : _a.value;
-    }
     /**
      * The function returns an iterator that iterates over the values of a linked list.
      */