priority-queue-typed 1.54.2 → 2.0.0

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

@@ -6,59 +6,27 @@
  * @license MIT License
  */
 import type { DoublyLinkedListOptions, ElementCallback } from '../../types';
-import { IterableElementBase } from '../base';
-export declare class DoublyLinkedListNode<E = any> {
+import { LinearLinkedBase, LinkedListNode } from '../base/linear-base';
+export declare class DoublyLinkedListNode<E = any> extends LinkedListNode<E> {
     /**
      * The constructor function initializes the value, next, and previous properties of an object.
      * @param {E} value - The "value" parameter is the value that will be stored in the node. It can be of any data type, as it
      * is defined as a generic type "E".
      */
     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: DoublyLinkedListNode<E> | undefined;
-    /**
-     * The "next" function returns the next node in a doubly linked list.
-     * @returns The `next` property is being returned. It can be either a `DoublyLinkedListNode<E>`
-     * object or `undefined`.
-     */
     get next(): DoublyLinkedListNode<E> | undefined;
-    /**
-     * The "next" property of a DoublyLinkedListNode is set to the provided value.
-     * @param {DoublyLinkedListNode<E> | undefined} value - The `value` parameter is of type
-     * `DoublyLinkedListNode<E> | undefined`. This means that it can accept either a
-     * `DoublyLinkedListNode` object or `undefined` as its value.
-     */
     set next(value: DoublyLinkedListNode<E> | undefined);
     protected _prev: DoublyLinkedListNode<E> | undefined;
-    /**
-     * The `prev` function returns the previous node in a doubly linked list.
-     * @returns The `prev` property of the `DoublyLinkedListNode` class is being returned. It can either
-     * be a `DoublyLinkedListNode` object or `undefined`.
-     */
     get prev(): DoublyLinkedListNode<E> | undefined;
-    /**
-     * The function sets the previous node of a doubly linked list node.
-     * @param {DoublyLinkedListNode<E> | undefined} value - The `value` parameter is of type
-     * `DoublyLinkedListNode<E> | undefined`. This means that it can accept either a
-     * `DoublyLinkedListNode` object or `undefined` as its value.
-     */
     set prev(value: DoublyLinkedListNode<E> | undefined);
 }
 /**
- *1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
+ * 1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
  * 2. Bidirectional Traversal: Unlike singly linked lists, doubly linked lists can be easily traversed forwards or backwards. This makes insertions and deletions in the list more flexible and efficient.
  * 3. No Centralized Index: Unlike arrays, elements in a linked list are not stored contiguously, so there is no centralized index. Accessing elements in a linked list typically requires traversing from the head or tail node.
  * 4. High Efficiency in Insertion and Deletion: Adding or removing elements in a linked list does not require moving other elements, making these operations more efficient than in arrays.
+ * Caution: Although our linked list classes provide methods such as at, setAt, addAt, and indexOf that are based on array indices, their time complexity, like that of the native Array.lastIndexOf, is 𝑂(𝑛). If you need to use these methods frequently, you might want to consider other data structures, such as Deque or Queue (designed for random access). Similarly, since the native Array.shift method has a time complexity of 𝑂(𝑛), using an array to simulate a queue can be inefficient. In such cases, you should use Queue or Deque, as these data structures leverage deferred array rearrangement, effectively reducing the average time complexity to 𝑂(1).
  * @example
  * // text editor operation history
  *     const actions = [
@@ -132,7 +100,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *         const initialNode = this.currentSong;
  *
  *         // Loop through the playlist twice
- *         for (let i = 0; i < this.playlist.size * 2; i++) {
+ *         for (let i = 0; i < this.playlist.length * 2; i++) {
  *           playedSongs.push(this.currentSong!.value);
  *           this.currentSong = this.currentSong!.next || this.playlist.head; // Loop back to the start if needed
  *         }
@@ -253,7 +221,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *         }
  *
  *         // Check capacity
- *         if (this.list.size >= this.capacity) {
+ *         if (this.list.length >= this.capacity) {
  *           // Delete the least recently used element (the tail of the linked list)
  *           const removedNode = this.list.tail;
  *           if (removedNode) {
@@ -298,9 +266,9 @@ export declare class DoublyLinkedListNode<E = any> {
  *         this.map.clear();
  *       }
  *
- *       // Get the current cache size
- *       get size(): number {
- *         return this.list.size;
+ *       // Get the current cache length
+ *       get length(): number {
+ *         return this.list.length;
  *       }
  *
  *       // Check if it is empty
@@ -359,7 +327,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *
  *     console.log(cache.delete('a')); // true
  *     console.log(cache.get('a')); // undefined
- *     console.log(cache.size); // 1
+ *     console.log(cache.length); // 1
  *
  *     // Should support clearing cache
  *     cache.clear();
@@ -367,7 +335,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *     cache.set('b', 2);
  *     cache.clear();
  *
- *     console.log(cache.size); // 0
+ *     console.log(cache.length); // 0
  *     console.log(cache.isEmpty); // true
  * @example
  * // finding lyrics by timestamp in Coldplay's "Fix You"
@@ -486,7 +454,7 @@ export declare class DoublyLinkedListNode<E = any> {
  *     scheduler.clear();
  *     console.log(scheduler.listProcesses()); // []
  */
-export declare class DoublyLinkedList<E = any, R = any> extends IterableElementBase<E, R, DoublyLinkedList<E, R>> {
+export declare class DoublyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, DoublyLinkedListNode<E>> {
     /**
      * This TypeScript constructor initializes a DoublyLinkedList with optional elements and options.
      * @param {Iterable<E> | Iterable<R>} elements - The `elements` parameter in the constructor is an
@@ -499,24 +467,11 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      */
     constructor(elements?: Iterable<E> | Iterable<R> | Iterable<DoublyLinkedListNode<E>>, options?: DoublyLinkedListOptions<E, R>);
     protected _head: DoublyLinkedListNode<E> | undefined;
-    /**
-     * The `head` function returns the first node of a doubly linked list.
-     * @returns The method `getHead()` returns either a `DoublyLinkedListNode<E>` object or `undefined`.
-     */
     get head(): DoublyLinkedListNode<E> | undefined;
     protected _tail: DoublyLinkedListNode<E> | undefined;
-    /**
-     * The `tail` function returns the last node of a doubly linked list.
-     * @returns The `get tail()` method is returning either a `DoublyLinkedListNode<E>` object or
-     * `undefined`.
-     */
     get tail(): DoublyLinkedListNode<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;
+    protected _length: number;
+    get length(): number;
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -678,7 +633,7 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * `addAt` method can be either a value of type `E` or a `DoublyLinkedListNode<E>` object.
      * @returns The `addAt` method returns a boolean value. It returns `true` if the element or node was
      * successfully added at the specified index, and `false` if the index is out of bounds (less than 0
-     * or greater than the size of the list).
+     * or greater than the length of the list).
      */
     addAt(index: number, newElementOrNode: E | DoublyLinkedListNode<E>): boolean;
     /**
@@ -714,6 +669,20 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * was not found in the linked list.
      */
     addAfter(existingElementOrNode: E | DoublyLinkedListNode<E>, newElementOrNode: E | DoublyLinkedListNode<E>): boolean;
+    /**
+     * Time Complexity: O(n)
+     * Space Complexity: O(1)
+     *
+     * The function `setAt` updates the value at a specified index in a data structure if the index
+     * exists.
+     * @param {number} index - The `index` parameter in the `setAt` method refers to the position in the
+     * data structure where you want to set a new value.
+     * @param {E} value - The `value` parameter in the `setAt` method represents the new value that you
+     * want to set at the specified index in the data structure.
+     * @returns The `setAt` method returns a boolean value - `true` if the value at the specified index
+     * is successfully updated, and `false` if the index is out of bounds.
+     */
+    setAt(index: number, value: E): boolean;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -724,7 +693,7 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * @returns The method `deleteAt` returns the value of the node that was deleted, or `undefined` if the index is out of
      * bounds.
      */
-    deleteAt(index: number): boolean;
+    deleteAt(index: number): E | undefined;
     /**
      * Time Complexity: O(1) or O(n)
      * Space Complexity: O(1)
@@ -743,7 +712,7 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The function checks if a variable has a size greater than zero and returns a boolean value.
+     * The function checks if a variable has a length greater than zero and returns a boolean value.
      * @returns A boolean value is being returned.
      */
     isEmpty(): boolean;
@@ -751,21 +720,9 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * Time Complexity: O(1)
      * Space Complexity: O(1)
      *
-     * The `clear` function resets the linked list by setting the head, tail, and size to undefined and 0 respectively.
+     * The `clear` function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.
      */
     clear(): void;
-    /**
-     * Time Complexity: O(n)
-     * Space Complexity: O(1)
-     *
-     * This function finds the index of a specified element, node, or predicate in a doubly linked list.
-     * @param {E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)} elementNodeOrPredicate
-     * elementNodeOrPredicate - The `indexOf` method takes in a parameter `elementNodeOrPredicate`, which
-     * can be one of the following:
-     * @returns The `indexOf` method returns the index of the element in the doubly linked list that
-     * matches the provided element, node, or predicate. If no match is found, it returns -1.
-     */
-    indexOf(elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): number;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -800,22 +757,6 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * The `reverse` function reverses the order of the elements in a doubly linked list.
      */
     reverse(): this;
-    /**
-     * 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)
-     * Space Complexity: O(n)
-     *
-     * The `toReversedArray` function converts a doubly linked list into an array in reverse order.
-     * @returns The `toReversedArray()` function returns an array of type `E[]`.
-     */
-    toReversedArray(): E[];
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -825,7 +766,7 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * @returns The `clone()` method is returning a new instance of the `DoublyLinkedList` class, which
      * is a copy of the original list.
      */
-    clone(): DoublyLinkedList<E, R>;
+    clone(): this;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -843,7 +784,7 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * @returns The `filter` method is returning a new `DoublyLinkedList` object that contains the
      * elements that pass the filter condition specified by the `callback` function.
      */
-    filter(callback: ElementCallback<E, R, boolean, DoublyLinkedList<E, R>>, thisArg?: any): DoublyLinkedList<E, R>;
+    filter(callback: ElementCallback<E, R, boolean>, thisArg?: any): DoublyLinkedList<E, R>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(n)
@@ -864,7 +805,7 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * value of
      * @returns a new instance of the `DoublyLinkedList` class with elements of type `T` and `RR`.
      */
-    map<EM, RM>(callback: ElementCallback<E, R, EM, DoublyLinkedList<E, R>>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): DoublyLinkedList<EM, RM>;
+    map<EM, RM>(callback: ElementCallback<E, R, EM>, toElementFn?: (rawElement: RM) => EM, thisArg?: any): DoublyLinkedList<EM, RM>;
     /**
      * Time Complexity: O(n)
      * Space Complexity: O(1)
@@ -881,6 +822,16 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * The function returns an iterator that iterates over the values of a linked list.
      */
     protected _getIterator(): IterableIterator<E>;
+    /**
+     * The function returns an iterator that iterates over the elements of a data structure in reverse
+     * order.
+     */
+    protected _getReverseIterator(): IterableIterator<E>;
+    /**
+     * The function returns an iterator that iterates over the nodes of a doubly linked list starting
+     * from the head.
+     */
+    protected _getNodeIterator(): IterableIterator<DoublyLinkedListNode<E>>;
     /**
      * The function `_isPredicate` checks if the input is a function that takes a `DoublyLinkedListNode`
      * as an argument and returns a boolean.
@@ -911,4 +862,24 @@ export declare class DoublyLinkedList<E = any, R = any> extends IterableElementB
      * returns a boolean value based on the conditions specified in the code.
      */
     protected _ensurePredicate(elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)): (node: DoublyLinkedListNode<E>) => boolean;
+    /**
+     * The function `_createInstance` returns a new instance of `DoublyLinkedList` with the specified
+     * options.
+     * @param [options] - The `options` parameter in the `_createInstance` method is of type
+     * `DoublyLinkedListOptions<E, R>`. It is an optional parameter that allows you to pass additional
+     * configuration options when creating a new instance of the `DoublyLinkedList` class.
+     * @returns An instance of the `DoublyLinkedList` class with an empty array and the provided options
+     * is being returned, cast as the current class type.
+     */
+    protected _createInstance(options?: DoublyLinkedListOptions<E, R>): this;
+    /**
+     * The function `_getPrevNode` returns the previous node of a given node in a doubly linked list.
+     * @param node - The parameter `node` in the `_getPrevNode` method is of type
+     * `DoublyLinkedListNode<E>`, which represents a node in a doubly linked list containing an element
+     * of type `E`.
+     * @returns The `_getPrevNode` method is returning the previous node of the input `node` in a doubly
+     * linked list. If the input node has a previous node, it will return that node. Otherwise, it will
+     * return `undefined`.
+     */
+    protected _getPrevNode(node: DoublyLinkedListNode<E>): DoublyLinkedListNode<E> | undefined;
 }