min-heap-typed 1.50.1 → 1.50.3

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

@@ -8,33 +8,73 @@
 import type { ElementCallback } from '../../types';
 import { IterableElementBase } from '../base';
 export declare class SinglyLinkedListNode<E = any> {
-    value: E;
-    next: SinglyLinkedListNode<E> | undefined;
     /**
      * The constructor function initializes an instance of a class with a given value and sets the next property to undefined.
      * @param {E} value - The "value" parameter is of type E, which means it can be any data type. It represents the value that
      * will be stored in the node of a linked list.
      */
     constructor(value: E);
+    protected _value: E;
+    /**
+     * The function returns the value of a protected variable.
+     * @returns The value of the variable `_value` is being returned.
+     */
+    get value(): E;
+    /**
+     * The above function sets the value of a variable.
+     * @param {E} value - The parameter "value" is of type E, which means it can be any type.
+     */
+    set value(value: E);
+    protected _next: SinglyLinkedListNode<E> | undefined;
+    /**
+     * The `next` function returns the next node in a singly linked list.
+     * @returns The `next` property is being returned. It can be either a `SinglyLinkedListNode<E>`
+     * object or `undefined`.
+     */
+    get next(): SinglyLinkedListNode<E> | undefined;
+    /**
+     * The "next" property of a SinglyLinkedListNode is set to the provided value.
+     * @param {SinglyLinkedListNode<E> | undefined} value - The `value` parameter is of type
+     * `SinglyLinkedListNode<E> | undefined`. This means that it can accept either a
+     * `SinglyLinkedListNode` object or `undefined` as its value.
+     */
+    set next(value: SinglyLinkedListNode<E> | undefined);
 }
 export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
     /**
-     * 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?: Iterable<E>);
     protected _head: SinglyLinkedListNode<E> | undefined;
+    /**
+     * 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(): SinglyLinkedListNode<E> | undefined;
     protected _tail: SinglyLinkedListNode<E> | undefined;
+    /**
+     * 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(): SinglyLinkedListNode<E> | undefined;
     protected _size: number;
+    /**
+     * The function returns the size of an object.
+     * @returns The size of the object, which is a number.
+     */
     get size(): number;
     /**
-     * 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.
@@ -43,12 +83,14 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     static fromArray<E>(data: E[]): SinglyLinkedList<E>;
     /**
-     * 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
@@ -56,12 +98,12 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     push(value: E): boolean;
     /**
-     * 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
@@ -69,12 +111,13 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     addLast(value: E): boolean;
     /**
-     * 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.
@@ -83,12 +126,12 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     pop(): E | undefined;
     /**
-     * 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.
@@ -97,36 +140,36 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     pollLast(): E | undefined;
     /**
-     * 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.
      */
     shift(): E | undefined;
     /**
-     * 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.
      */
     pollFirst(): E | undefined;
     /**
-     * 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
@@ -134,12 +177,12 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     unshift(value: E): boolean;
     /**
-     * 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
@@ -147,27 +190,28 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     addFirst(value: E): boolean;
     /**
-     * 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: number): E | undefined;
+    at(index: number): E | undefined;
     /**
-     * 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
@@ -177,12 +221,12 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     getNodeAt(index: number): SinglyLinkedListNode<E> | undefined;
     /**
-     * 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
@@ -192,12 +236,12 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     deleteAt(index: number): boolean;
     /**
-     * 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`
@@ -207,12 +251,12 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     delete(valueOrNode: E | SinglyLinkedListNode<E> | undefined): boolean;
     /**
-     * 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
@@ -234,51 +278,38 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     clear(): void;
     /**
-     * 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[]`.
      */
     toArray(): E[];
     /**
-     * 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.
      */
     reverse(): 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: (value: E) => boolean): E | 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.
@@ -287,12 +318,12 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     indexOf(value: E): number;
     /**
-     * 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.
@@ -302,12 +333,12 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     getNode(value: E): SinglyLinkedListNode<E> | 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
@@ -318,12 +349,12 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     addBefore(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
     /**
-     * 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
@@ -334,18 +365,32 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     addAfter(existingValueOrNode: E | SinglyLinkedListNode<E>, newValue: E): boolean;
     /**
-     * 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.
      * @returns The count of occurrences of the given value in the linked list.
      */
     countOccurrences(value: E): number;
+    /**
+     * 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(): SinglyLinkedList<E>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -369,7 +414,7 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      */
     filter(callback: ElementCallback<E, boolean>, thisArg?: any): SinglyLinkedList<E>;
     /**
-     * Time Complexity: O(n), where n is the number of elements in the linked list.
+     * Time Complexity: O(n)
      * Space Complexity: O(n)
      */
     /**
@@ -387,5 +432,8 @@ export declare class SinglyLinkedList<E = any> extends IterableElementBase<E> {
      * of applying the provided `callback` function to each element in the original list.
      */
     map<T>(callback: ElementCallback<E, T>, thisArg?: any): SinglyLinkedList<T>;
+    /**
+     * The function `_getIterator` returns an iterable iterator that yields the values of a linked list.
+     */
     protected _getIterator(): IterableIterator<E>;
 }