data-structure-typed 1.42.8 → 1.42.9

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

@@ -44,6 +44,13 @@ class SinglyLinkedList {
         return this._length;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the input array, as it performs a loop to push each element into the linked list.
+     * Space Complexity: O(n) - Linear space, as it creates a new node for each element in the array.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the input array, as it performs a loop to push each element into the linked list.
+     * Space Complexity: O(n) - Linear space, as it creates a new node for each element in the array.
+     *
      * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
      * array.
      * @param {E[]} data - The `data` parameter is an array of elements of type `E`.
@@ -57,6 +64,13 @@ class SinglyLinkedList {
         return singlyLinkedList;
     }
     /**
+     * Time Complexity: O(1) - Constant time, as it involves basic pointer adjustments.
+     * Space Complexity: O(1) - Constant space, as it only creates a new node.
+     */
+    /**
+     * Time Complexity: O(1) - Constant time, as it involves basic pointer adjustments.
+     * Space Complexity: O(1) - Constant space, as it only creates a new node.
+     *
      * The `push` function adds a new node with the given value to the end of a singly linked list.
      * @param {E} value - The "value" parameter represents the value that you want to add to the linked list. It can be of
      * any type (E) as specified in the generic type declaration of the class or function.
@@ -74,6 +88,13 @@ class SinglyLinkedList {
         this._length++;
     }
     /**
+     * Time Complexity: O(1) - Constant time, as it involves basic pointer adjustments.
+     * Space Complexity: O(1) - Constant space, as it only creates a new node.
+     */
+    /**
+     * Time Complexity: O(1) - Constant time, as it involves basic pointer adjustments.
+     * Space Complexity: O(1) - Constant space, as it only creates a new node.
+     *
      * The `push` function adds a new node with the given value to the end of a singly linked list.
      * @param {E} value - The "value" parameter represents the value that you want to add to the linked list. It can be of
      * any type (E) as specified in the generic type declaration of the class or function.
@@ -82,6 +103,13 @@ class SinglyLinkedList {
         this.push(value);
     }
     /**
+     * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
      * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
@@ -108,6 +136,13 @@ class SinglyLinkedList {
         return value;
     }
     /**
+     * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The `popLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
      * @returns The method `pop()` returns the value of the node that is being removed from the end of the linked list. If
@@ -117,6 +152,13 @@ class SinglyLinkedList {
         return this.pop();
     }
     /**
+     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The `shift()` function removes and returns the value of the first node in a linked list.
      * @returns The value of the node that is being removed from the beginning of the linked list.
      */
@@ -129,6 +171,13 @@ class SinglyLinkedList {
         return removedNode.value;
     }
     /**
+     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The `popFirst()` function removes and returns the value of the first node in a linked list.
      * @returns The value of the node that is being removed from the beginning of the linked list.
      */
@@ -136,6 +185,13 @@ class SinglyLinkedList {
         return this.shift();
     }
     /**
+     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The unshift function adds a new node with the given value to the beginning of a singly linked list.
      * @param {E} value - The parameter "value" represents the value of the new node that will be added to the beginning of the
      * linked list.
@@ -153,6 +209,13 @@ class SinglyLinkedList {
         this._length++;
     }
     /**
+     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The addFirst function adds a new node with the given value to the beginning of a singly linked list.
      * @param {E} value - The parameter "value" represents the value of the new node that will be added to the beginning of the
      * linked list.
@@ -161,6 +224,13 @@ class SinglyLinkedList {
         this.unshift(value);
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The function `getAt` returns the value at a specified index in a linked list, or null if the index is out of range.
      * @param {number} index - The index parameter is a number that represents the position of the element we want to
      * retrieve from the list.
@@ -177,6 +247,13 @@ class SinglyLinkedList {
         return current.value;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The function `getNodeAt` returns the node at a given index in a singly linked list.
      * @param {number} index - The `index` parameter is a number that represents the position of the node we want to
      * retrieve from the linked list. It indicates the zero-based index of the node we want to access.
@@ -191,6 +268,13 @@ class SinglyLinkedList {
         return current;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The `deleteAt` function removes an element at a specified index from a linked list and returns the removed element.
      * @param {number} index - The index parameter represents the position of the element that needs to be deleted in the
      * data structure. It is of type number.
@@ -211,6 +295,13 @@ class SinglyLinkedList {
         return removedNode.value;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The delete function removes a node with a specific value from a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} valueOrNode - The `valueOrNode` parameter can accept either a value of type `E`
      * or a `SinglyLinkedListNode<E>` object.
@@ -251,6 +342,13 @@ class SinglyLinkedList {
         return false;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The `insertAt` function inserts a value at a specified index in a singly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
      * linked list. It is of type number.
@@ -294,6 +392,13 @@ class SinglyLinkedList {
         this._length = 0;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to traverse the entire list to convert it to an array.
+     * Space Complexity: O(n) - Linear space, as it creates an array with the same length as the list.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to traverse the entire list to convert it to an array.
+     * Space Complexity: O(n) - Linear space, as it creates an array with the same length as the list.
+     *
      * The `toArray` function converts a linked list into an array.
      * @returns The `toArray()` method is returning an array of type `E[]`.
      */
@@ -307,6 +412,13 @@ class SinglyLinkedList {
         return array;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The `reverse` function reverses the order of the nodes in a singly linked list.
      * @returns The reverse() method does not return anything. It has a return type of void.
      */
@@ -325,6 +437,13 @@ class SinglyLinkedList {
         [this._head, this._tail] = [this.tail, this.head];
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The `find` function iterates through a linked list and returns the first element that satisfies a given condition.
      * @param callback - A function that takes a value of type E as its parameter and returns a boolean value. This
      * function is used to determine whether a particular value in the linked list satisfies a certain condition.
@@ -342,6 +461,13 @@ class SinglyLinkedList {
         return null;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The `indexOf` function returns the index of the first occurrence of a given value in a linked list.
      * @param {E} value - The value parameter is the value that you want to find the index of in the linked list.
      * @returns The method is returning the index of the first occurrence of the specified value in the linked list. If the
@@ -360,6 +486,13 @@ class SinglyLinkedList {
         return -1;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The function finds a node in a singly linked list by its value and returns the node if found, otherwise returns
      * null.
      * @param {E} value - The value parameter is the value that we want to search for in the linked list.
@@ -377,6 +510,13 @@ class SinglyLinkedList {
         return null;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The `insertBefore` function inserts a new value before an existing value in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
      * new value before. It can be either the value itself or a node containing the value in the linked list.
@@ -412,6 +552,13 @@ class SinglyLinkedList {
         return false;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The `insertAfter` function inserts a new node with a given value after an existing node in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node in the linked list after which
      * the new value will be inserted. It can be either the value of the existing node or the existing node itself.
@@ -440,6 +587,13 @@ class SinglyLinkedList {
         return false;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The function counts the number of occurrences of a given value in a linked list.
      * @param {E} value - The value parameter is the value that you want to count the occurrences of in the linked list.
      * @returns The count of occurrences of the given value in the linked list.
@@ -456,6 +610,13 @@ class SinglyLinkedList {
         return count;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
+     * Space Complexity: O(1) - Constant space.
+     *
      * The `forEach` function iterates over each element in a linked list and applies a callback function to each element.
      * @param callback - The callback parameter is a function that takes two arguments: value and index. The value argument
      * represents the value of the current node in the linked list, and the index argument represents the index of the
@@ -471,6 +632,13 @@ class SinglyLinkedList {
         }
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
+     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
+     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     *
      * The `map` function takes a callback function and applies it to each element in the SinglyLinkedList, returning a new
      * SinglyLinkedList with the transformed values.
      * @param callback - The callback parameter is a function that takes a value of type E (the type of values stored in
@@ -488,6 +656,13 @@ class SinglyLinkedList {
         return mappedList;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
+     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
+     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     *
      * The `filter` function iterates through a SinglyLinkedList and returns a new SinglyLinkedList containing only the
      * elements that satisfy the given callback function.
      * @param callback - The `callback` parameter is a function that takes a value of type `E` and returns a boolean value.
@@ -506,6 +681,13 @@ class SinglyLinkedList {
         return filteredList;
     }
     /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
+     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     */
+    /**
+     * Time Complexity: O(n) - Linear time, where n is the length of the list, as they need to traverse the entire list to apply the callback or reduce the list.
+     * Space Complexity: O(n) - Linear space, as they create new nodes or arrays.
+     *
      * The `reduce` function iterates over a linked list and applies a callback function to each element, accumulating a
      * single value.
      * @param callback - The `callback` parameter is a function that takes two arguments: `accumulator` and `value`. It is

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

@@ -29,6 +29,13 @@ export declare class SkipList<K, V> {
     protected _probability: number;
     get probability(): number;
     /**
+     * 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.
+     *
      * 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
@@ -36,14 +43,36 @@ export declare class SkipList<K, V> {
      */
     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.
+     */
+    /**
+     * 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(key: K): 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.
+     */
+    /**
+     * 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.
+     */
     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.
+     */
+    /**
+     * 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
@@ -51,28 +80,63 @@ export declare class SkipList<K, V> {
      */
     delete(key: K): boolean;
     /**
+     * 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.
      */
     getFirst(): 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.
+     */
+    /**
+     * 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.
      */
     getLast(): 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.
+     */
+    /**
+     * 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 in the Skip List that is greater than the given key.
      * @param key - the given key.
      * @returns The value of the first element greater than the given key, or undefined if there is no such element.
      */
     higher(key: K): 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.
+     */
+    /**
+     * 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 in the Skip List that is less than the given key.
      * @param key - the given key.
      * @returns The value of the last element less than the given key, or undefined if there is no such element.
      */
     lower(key: K): V | undefined;
     /**
+     * Time Complexity: O(maxLevel) - where maxLevel is the maximum level of the SkipList, as it may iterate up to maxLevel times in the worst case.
+     * Space Complexity: O(1) - constant space.
+     */
+    /**
+     * Time Complexity: O(maxLevel) - where maxLevel is the maximum level of the SkipList, as it may iterate up to maxLevel times in the worst case.
+     * Space Complexity: O(1) - constant space.
+     *
      * The function "_randomLevel" generates a random level based on a given probability and maximum level.
      * @returns the level, which is a number.
      */

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

@@ -50,6 +50,13 @@ class SkipList {
         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(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
@@ -74,6 +81,13 @@ class 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.
+     */
+    /**
+     * 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,
@@ -92,10 +106,25 @@ 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.
+     * 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.
+     */
     has(key) {
         return this.get(key) !== 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.
+     *
      * 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
@@ -126,6 +155,13 @@ 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.
      */
@@ -134,6 +170,13 @@ class SkipList {
         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.
      */
@@ -147,6 +190,13 @@ class SkipList {
         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.
+     */
+    /**
+     * 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 in the Skip List that is greater than the given key.
      * @param key - the given key.
      * @returns The value of the first element greater than the given key, or undefined if there is no such element.
@@ -162,6 +212,13 @@ class SkipList {
         return nextNode ? nextNode.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 in the Skip List that is less than the given key.
      * @param key - the given key.
      * @returns The value of the last element less than the given key, or undefined if there is no such element.
@@ -180,6 +237,13 @@ class SkipList {
         return lastLess ? lastLess.value : undefined;
     }
     /**
+     * Time Complexity: O(maxLevel) - where maxLevel is the maximum level of the SkipList, as it may iterate up to maxLevel times in the worst case.
+     * Space Complexity: O(1) - constant space.
+     */
+    /**
+     * Time Complexity: O(maxLevel) - where maxLevel is the maximum level of the SkipList, as it may iterate up to maxLevel times in the worst case.
+     * Space Complexity: O(1) - constant space.
+     *
      * The function "_randomLevel" generates a random level based on a given probability and maximum level.
      * @returns the level, which is a number.
      */