min-heap-typed 1.42.8 → 1.42.9

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -49,6 +49,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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`.
@@ -63,6 +71,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -80,6 +96,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -89,6 +113,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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
@@ -116,6 +148,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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
@@ -126,6 +166,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
    */
@@ -138,6 +186,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
    */
@@ -146,6 +202,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -163,6 +227,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -172,6 +244,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -188,6 +268,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -203,6 +291,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -222,6 +318,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -263,6 +367,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -309,6 +421,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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[]`.
    */
@@ -323,6 +443,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
    */
@@ -344,6 +472,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -362,6 +498,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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
@@ -383,6 +527,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -403,6 +555,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -440,6 +600,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -471,6 +639,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -490,6 +666,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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
@@ -506,6 +690,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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
@@ -524,6 +716,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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.
@@ -543,6 +743,14 @@ export class SinglyLinkedList<E = any> {
   }
 
   /**
+   * 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/src/data-structures/linked-list/skip-linked-list.ts

@@ -58,6 +58,14 @@ export 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.
+   */
+
+  /**
+   * 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
@@ -86,6 +94,14 @@ export 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.
+   */
+
+  /**
+   * 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,
@@ -108,11 +124,29 @@ export class SkipList<K, V> {
     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: K): boolean {
     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
@@ -148,6 +182,14 @@ export class SkipList<K, V> {
   }
 
   /**
+   * 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.
    */
@@ -157,6 +199,14 @@ export 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.
+   */
+
+  /**
+   * 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.
    */
@@ -171,6 +221,14 @@ export 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.
+   */
+
+  /**
+   * 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.
@@ -187,6 +245,14 @@ export 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.
+   */
+
+  /**
+   * 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.
@@ -208,6 +274,14 @@ export class SkipList<K, V> {
   }
 
   /**
+   * 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.
    */