linked-list-typed 1.49.2 → 1.49.4

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

@@ -33,15 +33,13 @@ export declare class SkipList<K, V> {
      * Space Complexity: O(1) - constant space, as it uses a fixed amount of space regardless of the size of the SkipList.
      */
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
+     * Time Complexity: O(1) - 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.
      *
-     * The add function adds a new node with a given key and value to a Skip List data structure.
-     * @param {K} key - The key parameter represents the key of the node that needs to be added to the skip list.
-     * @param {V} value - The "value" parameter represents the value associated with the key that is being added to the Skip
-     * List.
+     * 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.
      */
-    add(key: K, value: V): void;
+    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.
@@ -50,12 +48,10 @@ export declare class SkipList<K, V> {
      * 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.
      *
-     * The function `get` retrieves the value associated with a given key from a skip list data structure.
-     * @param {K} key - The `key` parameter is the key of the element that we want to retrieve from the data structure.
-     * @returns The method `get(key: K)` returns the value associated with the given key if it exists in the data structure,
-     * otherwise it returns `undefined`.
+     * 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.
      */
-    get(key: K): 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.
@@ -63,8 +59,13 @@ export declare class SkipList<K, V> {
     /**
      * 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.
+     *
+     * The add function adds a new node with a given key and value to a Skip List data structure.
+     * @param {K} key - The key parameter represents the key of the node that needs to be added to the skip list.
+     * @param {V} value - The "value" parameter represents the value associated with the key that is being added to the Skip
+     * List.
      */
-    has(key: K): boolean;
+    add(key: K, value: V): void;
     /**
      * 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.
@@ -73,24 +74,21 @@ export declare class SkipList<K, V> {
      * 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.
      *
-     * The `delete` function removes a node with a specific key from a Skip List data structure.
-     * @param {K} key - The key parameter represents the key of the node that needs to be removed from the skip list.
-     * @returns The `delete` method returns a boolean value. It returns `true` if the key was successfully removed from the
-     * skip list, and `false` if the key was not found in the skip list.
+     * The function `get` retrieves the value associated with a given key from a skip list data structure.
+     * @param {K} key - The `key` parameter is the key of the element that we want to retrieve from the data structure.
+     * @returns The method `get(key: K)` returns the value associated with the given key if it exists in the data structure,
+     * otherwise it returns `undefined`.
      */
-    delete(key: K): boolean;
+    get(key: K): V | undefined;
     /**
      * Time Complexity: O(1) - 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.
      */
     /**
-     * Time Complexity: O(1) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
+     * 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.
-     *
-     * 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.
      */
-    get first(): V | undefined;
+    has(key: K): boolean;
     /**
      * 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.
@@ -99,10 +97,12 @@ export declare class SkipList<K, V> {
      * 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.
      *
-     * 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.
+     * The `delete` function removes a node with a specific key from a Skip List data structure.
+     * @param {K} key - The key parameter represents the key of the node that needs to be removed from the skip list.
+     * @returns The `delete` method returns a boolean value. It returns `true` if the key was successfully removed from the
+     * skip list, and `false` if the key was not found in the skip list.
      */
-    get last(): V | undefined;
+    delete(key: K): boolean;
     /**
      * 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/data-structures/linked-list/skip-linked-list.js

@@ -42,6 +42,41 @@ class SkipList {
     get probability() {
         return this._probability;
     }
+    /**
+     * 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.
+     */
+    /**
+     * Time Complexity: O(1) - 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.
+     *
+     * 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.
+     */
+    get first() {
+        const firstNode = this.head.forward[0];
+        return firstNode ? firstNode.value : 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.
+     */
+    /**
+     * 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.
+     *
+     * 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.
+     */
+    get last() {
+        let current = this.head;
+        for (let i = this.level - 1; i >= 0; i--) {
+            while (current.forward[i]) {
+                current = current.forward[i];
+            }
+        }
+        return current.value;
+    }
     /**
      * 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.
@@ -100,7 +135,7 @@ class SkipList {
         return undefined;
     }
     /**
-     * Time Complexity: O(log n) - where n is the number of elements in the SkipList, as it traverses the levels of the SkipList.
+     * Time Complexity: O(1) - 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.
      */
     /**
@@ -147,41 +182,6 @@ class SkipList {
         }
         return false;
     }
-    /**
-     * Time Complexity: O(1) - 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.
-     */
-    /**
-     * Time Complexity: O(1) - 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.
-     *
-     * 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.
-     */
-    get first() {
-        const firstNode = this.head.forward[0];
-        return firstNode ? firstNode.value : 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.
-     */
-    /**
-     * 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.
-     *
-     * 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.
-     */
-    get last() {
-        let current = this.head;
-        for (let i = this.level - 1; i >= 0; i--) {
-            while (current.forward[i]) {
-                current = current.forward[i];
-            }
-        }
-        return current.value;
-    }
     /**
      * 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/data-structures/queue/queue.d.ts

@@ -32,6 +32,32 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
      */
     get size(): number;
+    /**
+     * 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 `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`.
+     */
+    get first(): E | undefined;
+    /**
+     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
+     * Space Complexity: O(1) - no additional space is used.
+     */
+    /**
+     * 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 `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`.
+     */
+    get last(): E | undefined;
+    /**
+     * 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.
+     */
     /**
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
@@ -42,7 +68,7 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      */
     static fromArray<E>(elements: E[]): Queue<E>;
     /**
-     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      */
     /**
@@ -55,7 +81,7 @@ export declare class Queue<E = any> extends IterableElementBase<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.
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      */
     /**
@@ -67,19 +93,6 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * @returns The function `shift()` returns either the first element in the queue or `undefined` if the queue is empty.
      */
     shift(): 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.
-     */
-    /**
-     * 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 `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`.
-     */
-    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.
@@ -93,19 +106,6 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     peek(): 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.
-     */
-    /**
-     * 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 `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`.
-     */
-    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.
@@ -247,6 +247,11 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
  * 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 `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`.
+     */
+    get first(): E | undefined;
     /**
      * 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.
@@ -257,11 +262,6 @@ export declare class LinkedListQueue<E = any> extends SinglyLinkedList<E> {
      * @returns The method is returning the element at the front of the queue, or undefined if the queue is empty.
      */
     dequeue(): E | 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`.
-     */
-    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

@@ -37,6 +37,36 @@ class Queue extends base_1.IterableElementBase {
     get size() {
         return this.nodes.length - this.offset;
     }
+    /**
+     * 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 `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`.
+     */
+    get first() {
+        return this.size > 0 ? this.nodes[this.offset] : undefined;
+    }
+    /**
+     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
+     * Space Complexity: O(1) - no additional space is used.
+     */
+    /**
+     * 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 `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`.
+     */
+    get last() {
+        return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
+    }
+    /**
+     * 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.
+     */
     /**
      * The function "fromArray" creates a new Queue object from an array of elements.Creates a queue from an existing array.
      * @public
@@ -49,7 +79,7 @@ class Queue extends base_1.IterableElementBase {
         return new Queue(elements);
     }
     /**
-     * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      */
     /**
@@ -65,7 +95,7 @@ class Queue extends base_1.IterableElementBase {
         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.
+     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      */
     /**
@@ -89,21 +119,6 @@ class Queue extends base_1.IterableElementBase {
         this._offset = 0;
         return first;
     }
-    /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
-     */
-    /**
-     * 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 `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`.
-     */
-    get first() {
-        return this.size > 0 ? this.nodes[this.offset] : 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.
@@ -119,21 +134,6 @@ class Queue extends base_1.IterableElementBase {
     peek() {
         return this.first;
     }
-    /**
-     * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
-     * Space Complexity: O(1) - no additional space is used.
-     */
-    /**
-     * 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 `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`.
-     */
-    get last() {
-        return this.size > 0 ? this.nodes[this.nodes.length - 1] : 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.
@@ -315,6 +315,14 @@ exports.Queue = Queue;
  * 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 `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`.
+     */
+    get first() {
+        var _a;
+        return (_a = this.head) === null || _a === void 0 ? void 0 : _a.value;
+    }
     /**
      * 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.
@@ -329,14 +337,6 @@ class LinkedListQueue extends linked_list_1.SinglyLinkedList {
     dequeue() {
         return this.shift();
     }
-    /**
-     * 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`.
-     */
-    get first() {
-        var _a;
-        return (_a = this.head) === null || _a === void 0 ? void 0 : _a.value;
-    }
     /**
      * 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linked-list-typed",
-  "version": "1.49.2",
+  "version": "1.49.4",
   "description": "Linked List, Doubly Linked List, Singly Linked List. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -66,6 +66,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.49.1"
+    "data-structure-typed": "^1.49.4"
   }
 }

package/src/data-structures/binary-tree/binary-tree.ts

@@ -1957,7 +1957,7 @@ export class BinaryTree<K = any, V = any, N extends BinaryTreeNode<K, V, N> = Bi
     }
   }
 
-  protected _defaultOneParamCallback = (node: N) => node.key;
+  protected _defaultOneParamCallback = (node: N | null | undefined) => node ? node.key : undefined;
 
   /**
    * Swap the data of two nodes in the binary tree.

package/src/data-structures/graph/abstract-graph.ts

@@ -156,10 +156,10 @@ export abstract class AbstractGraph<
 
   addVertex(keyOrVertex: VertexKey | VO, value?: V): boolean {
     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);
     }
   }
 
@@ -173,19 +173,7 @@ export abstract class AbstractGraph<
    * 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 {
-    const vertexKey = this._getVertexKey(vertexOrKey);
-    return this._vertexMap.delete(vertexKey);
-  }
+  abstract deleteVertex(vertexOrKey: VO | VertexKey): boolean;
 
   /**
    * Time Complexity: O(K), where K is the number of vertexMap to be removed.
@@ -242,14 +230,14 @@ export abstract class AbstractGraph<
 
   addEdge(srcOrEdge: VO | VertexKey | EO, dest?: VO | VertexKey, weight?: number, value?: E): boolean {
     if (srcOrEdge instanceof AbstractEdge) {
-      return this._addEdgeOnly(srcOrEdge);
+      return this._addEdge(srcOrEdge);
     } else {
       if (dest instanceof AbstractVertex || typeof dest === 'string' || typeof dest === 'number') {
         if (!(this.hasVertex(srcOrEdge) && this.hasVertex(dest))) return false;
         if (srcOrEdge instanceof AbstractVertex) srcOrEdge = srcOrEdge.key;
         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');
       }
@@ -1147,14 +1135,6 @@ export abstract class AbstractGraph<
     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(): Map<number, VO[]> {
-    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.
@@ -1180,6 +1160,55 @@ export abstract class AbstractGraph<
     return this.tarjan(false, true, false, false).bridges;
   }
 
+  /**
+   * O(V+E+C)
+   * O(V+C)
+   */
+  getCycles(isInclude2Cycle: boolean = false): VertexKey[][] {
+    const cycles: VertexKey[][] = [];
+    const visited: Set<VO> = new Set();
+
+    const dfs = (vertex: VO, currentPath: VertexKey[], visited: Set<VO>) => {
+      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<string, VertexKey[]>();
+
+    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)
@@ -1247,9 +1276,9 @@ export abstract class AbstractGraph<
     }
   }
 
-  protected abstract _addEdgeOnly(edge: EO): boolean;
+  protected abstract _addEdge(edge: EO): boolean;
 
-  protected _addVertexOnly(newVertex: VO): boolean {
+  protected _addVertex(newVertex: VO): boolean {
     if (this.hasVertex(newVertex)) {
       return false;
       // throw (new Error('Duplicated vertex key is not allowed'));

package/src/data-structures/graph/directed-graph.ts

@@ -240,7 +240,7 @@ export class DirectedGraph<
    * (`VertexKey`).
    * @returns The method is returning a boolean value.
    */
-  override deleteVertex(vertexOrKey: VO | VertexKey): boolean {
+  deleteVertex(vertexOrKey: VO | VertexKey): boolean {
     let vertexKey: VertexKey;
     let vertex: VO | undefined;
     if (this.isVertexKey(vertexOrKey)) {
@@ -252,8 +252,12 @@ export class DirectedGraph<
     }
 
     if (vertex) {
-      this._outEdgeMap.delete(vertex)
-      this._inEdgeMap.delete(vertex)
+      const neighbors = this.getNeighbors(vertex);
+      for (const neighbor of neighbors) {
+        this._inEdgeMap.delete(neighbor);
+      }
+      this._outEdgeMap.delete(vertex);
+      this._inEdgeMap.delete(vertex);
     }
 
     return this._vertexMap.delete(vertexKey);
@@ -596,6 +600,7 @@ export class DirectedGraph<
     }
   }
 
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)
@@ -605,13 +610,13 @@ export class DirectedGraph<
    * 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 {
     if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
       return false;
     }

package/src/data-structures/graph/undirected-graph.ts

@@ -212,7 +212,7 @@ export class UndirectedGraph<
    * (`VertexKey`).
    * @returns The method is returning a boolean value.
    */
-  override deleteVertex(vertexOrKey: VO | VertexKey): boolean {
+  deleteVertex(vertexOrKey: VO | VertexKey): boolean {
     let vertexKey: VertexKey;
     let vertex: VO | undefined;
     if (this.isVertexKey(vertexOrKey)) {
@@ -381,7 +381,7 @@ export class UndirectedGraph<
    * @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 {
     for (const end of edge.vertexMap) {
       const endVertex = this._getVertex(end);
       if (endVertex === undefined) return false;