min-heap-typed 1.50.1 → 1.50.2

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

@@ -16,7 +16,10 @@ class SinglyLinkedListNode {
 exports.SinglyLinkedListNode = SinglyLinkedListNode;
 class SinglyLinkedList extends base_1.IterableElementBase {
     /**
-     * The constructor initializes the linked list with an empty head, tail, and length.
+     * The constructor initializes a new instance of a class with an optional iterable of elements.
+     * @param elements - The `elements` parameter is an optional iterable object that contains the
+     * initial elements to be added to the instance of the class. If no `elements` are provided, an empty
+     * array will be used as the default value.
      */
     constructor(elements = []) {
         super();
@@ -26,22 +29,36 @@ class SinglyLinkedList extends base_1.IterableElementBase {
                 this.push(el);
         }
     }
+    /**
+     * The `head` function returns the first node of a singly linked list.
+     * @returns The method is returning either a SinglyLinkedListNode object or undefined.
+     */
     get head() {
         return this._head;
     }
+    /**
+     * The `tail` function returns the last node of a singly linked list.
+     * @returns The method is returning either a SinglyLinkedListNode object or undefined.
+     */
     get tail() {
         return this._tail;
     }
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size() {
         return this._size;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the input array, as it performs a loop to push each element into the linked list.
-     * Space Complexity: O(n) - Linear space, as it creates a new node for each element in the array.
+     * Time Complexity: O(n)
+     * Space 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.
+     * 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.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
      * The `fromArray` function creates a new SinglyLinkedList instance and populates it with the elements from the given
      * array.
@@ -56,12 +73,14 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         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)
+     * Space Complexity: O(1)
+     * Constant time, as it involves basic pointer adjustments.
+     * 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.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * 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
@@ -81,12 +100,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         return true;
     }
     /**
-     * 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)
+     * Space Complexity: O(1)
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * 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
@@ -96,12 +115,13 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         return this.push(value);
     }
     /**
-     * Time Complexity: O(n) - Linear time in the worst case, as it may need to traverse the list to find the last element.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * Linear time in the worst case, as it may need to traverse the list to find the last element.
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * The `pop()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
@@ -129,12 +149,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         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)
+     * Space Complexity: O(1)
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * The `pollLast()` function removes and returns the value of the last element in a linked list, updating the head and tail
      * pointers accordingly.
@@ -145,12 +165,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         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)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * 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.
@@ -164,12 +184,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         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)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * The `pollFirst()` 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.
@@ -178,12 +198,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         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)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * 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
@@ -203,12 +223,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         return true;
     }
     /**
-     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      */
     /**
-     * Time Complexity: O(1) - Constant time, as it involves adjusting pointers at the head.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(1)
+     * Space Complexity: O(1)
      *
      * 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
@@ -218,20 +238,21 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         return this.unshift(value);
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     * Linear time, where n is the index, as it may need to traverse the list to find the desired node.
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
-     * The function `getAt` returns the value at a specified index in a linked list, or undefined if the index is out of range.
+     * The function `at` returns the value at a specified index in a linked list, or undefined 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.
-     * @returns The method `getAt(index: number): E | undefined` returns the value at the specified index in the linked list, or
+     * @returns The method `at(index: number): E | undefined` returns the value at the specified index in the linked list, or
      * `undefined` if the index is out of bounds.
      */
-    getAt(index) {
+    at(index) {
         if (index < 0 || index >= this.size)
             return undefined;
         let current = this.head;
@@ -241,12 +262,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         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)
+     * Space Complexity: O(1)
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * 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
@@ -262,12 +283,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         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)
+     * Space Complexity: O(1)
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * 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
@@ -293,12 +314,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         return true;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the index, as it may need to traverse the list to find the desired node.
-     * Space Complexity: O(1) - Constant space.
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * 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`
@@ -340,12 +361,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         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)
+     * Space Complexity: O(1)
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * The `addAt` function inserts a value at a specified index in a singly linked list.
      * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
@@ -390,12 +411,14 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         this._size = 0;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to traverse the entire list to convert it to an array.
-     * Space Complexity: O(n) - Linear space, as it creates an array with the same length as the list.
+     * Time Complexity: O(n)
+     * Space 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.
+     * 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.
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
      *
      * The `toArray` function converts a linked list into an array.
      * @returns The `toArray()` method is returning an array of type `E[]`.
@@ -410,12 +433,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         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)
+     * Space Complexity: O(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)
+     * Space Complexity: O(1)
      *
      * 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.
@@ -436,36 +459,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         return this;
     }
     /**
-     * Time Complexity: O(n) - Linear time, where n is the length of the list, as it needs to reverse the pointers of each node.
-     * 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.
-     * @returns The method `find` returns the first element in the linked list that satisfies the condition specified by
-     * the callback function. If no element satisfies the condition, it returns `undefined`.
-     */
-    find(callback) {
-        let current = this.head;
-        while (current) {
-            if (callback(current.value)) {
-                return current.value;
-            }
-            current = current.next;
-        }
-        return undefined;
-    }
-    /**
-     * 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)
+     * Space Complexity: O(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)
+     * Space Complexity: O(1)
      *
      * 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.
@@ -485,12 +484,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         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)
+     * Space Complexity: O(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)
+     * Space Complexity: O(1)
      *
      * The function finds a node in a singly linked list by its value and returns the node if found, otherwise returns
      * undefined.
@@ -509,12 +508,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         return undefined;
     }
     /**
-     * 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)
+     * Space Complexity: O(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)
+     * Space Complexity: O(1)
      *
      * The `addBefore` function inserts a new value before an existing value in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node that you want to insert the
@@ -551,12 +550,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         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)
+     * Space Complexity: O(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)
+     * Space Complexity: O(1)
      *
      * The `addAfter` function inserts a new node with a given value after an existing node in a singly linked list.
      * @param {E | SinglyLinkedListNode<E>} existingValueOrNode - The existing value or node in the linked list after which
@@ -586,12 +585,12 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         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)
+     * Space Complexity: O(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)
+     * Space Complexity: O(1)
      *
      * 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.
@@ -608,6 +607,22 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         }
         return count;
     }
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     */
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(n)
+     *
+     * The `clone` function returns a new instance of the `SinglyLinkedList` class with the same values
+     * as the original list.
+     * @returns The `clone()` method is returning a new instance of the `SinglyLinkedList` class, which
+     * is a clone of the original list.
+     */
+    clone() {
+        return new SinglyLinkedList(this.values());
+    }
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -667,6 +682,9 @@ class SinglyLinkedList extends base_1.IterableElementBase {
         }
         return mappedList;
     }
+    /**
+     * The function `_getIterator` returns an iterable iterator that yields the values of a linked list.
+     */
     *_getIterator() {
         let current = this.head;
         while (current) {

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

@@ -13,46 +13,70 @@ export declare class SkipListNode<K, V> {
     constructor(key: K, value: V, level: number);
 }
 export declare class SkipList<K, V> {
+    /**
+     * The constructor function initializes a SkipLinkedList object with optional options and elements.
+     * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
+     * is used to initialize the SkipLinkedList with the given key-value pairs. If no elements are
+     * provided, the SkipLinkedList will be empty.
+     * @param {SkipLinkedListOptions} [options] - The `options` parameter is an optional object that can
+     * contain two properties:
+     */
     constructor(elements?: Iterable<[K, V]>, options?: SkipLinkedListOptions);
     protected _head: SkipListNode<K, V>;
+    /**
+     * The function returns the head node of a SkipList.
+     * @returns The method is returning a SkipListNode object with generic key type K and value type V.
+     */
     get head(): SkipListNode<K, V>;
     protected _level: number;
+    /**
+     * The function returns the value of the private variable _level.
+     * @returns The level property of the object.
+     */
     get level(): number;
     protected _maxLevel: number;
+    /**
+     * The function returns the maximum level.
+     * @returns The value of the variable `_maxLevel` is being returned.
+     */
     get maxLevel(): number;
     protected _probability: number;
+    /**
+     * The function returns the probability value.
+     * @returns The probability value stored in the private variable `_probability` is being returned.
+     */
     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)
+     * Space Complexity: O(1)
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * 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;
     /**
-     * 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)
+     * Space Complexity: O(1)
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * 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(): 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)
+     * Space Complexity: O(1)
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * 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.
@@ -61,12 +85,12 @@ 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)
+     * Space Complexity: O(1)
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * 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.
@@ -75,21 +99,23 @@ export declare class SkipList<K, V> {
      */
     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(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * 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 checks if a key exists in a data structure.
+     * @param {K} key - The parameter "key" is of type K, which represents the type of the key being
+     * checked.
+     * @returns a boolean value.
      */
     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)
+     * Space Complexity: O(1)
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * 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.
@@ -98,12 +124,12 @@ export declare class SkipList<K, V> {
      */
     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.
+     * Time Complexity: O(log n)
+     * Space Complexity: O(1)
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * Get the value of the first element in the Skip List that is greater than the given key.
      * @param key - the given key.
@@ -111,12 +137,12 @@ export declare class SkipList<K, V> {
      */
     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)
+     * Space Complexity: O(1)
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * Get the value of the last element in the Skip List that is less than the given key.
      * @param key - the given key.
@@ -124,12 +150,13 @@ export declare class SkipList<K, V> {
      */
     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)
+     * Space Complexity: O(1)
+     * where maxLevel is the maximum level of the SkipList, as it may iterate up to maxLevel times in the worst case.
      */
     /**
-     * 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)
+     * Space Complexity: O(1)
      *
      * The function "_randomLevel" generates a random level based on a given probability and maximum level.
      * @returns the level, which is a number.