min-heap-typed 1.50.1 → 1.50.3

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

@@ -9,19 +9,75 @@ import type { ElementCallback } from '../../types';
 import { IterableElementBase } from '../base';
 
 export class DoublyLinkedListNode<E = any> {
-  value: E;
-  next: DoublyLinkedListNode<E> | undefined;
-  prev: DoublyLinkedListNode<E> | undefined;
-
   /**
    * 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) {
-    this.value = value;
-    this.next = undefined;
-    this.prev = undefined;
+    this._value = value;
+    this._next = undefined;
+    this._prev = undefined;
+  }
+
+  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 {
+    return this._value;
+  }
+
+  /**
+   * 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) {
+    this._value = value;
+  }
+
+  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 {
+    return this._next;
+  }
+
+  /**
+   * 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) {
+    this._next = value;
+  }
+
+  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 {
+    return this._prev;
+  }
+
+  /**
+   * 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) {
+    this._prev = value;
   }
 }
 
@@ -33,7 +89,10 @@ export class DoublyLinkedListNode<E = any> {
  */
 export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   /**
-   * The constructor initializes the linked list with an empty head, tail, and size.
+   * The constructor initializes a linked list with optional elements.
+   * @param elements - The `elements` parameter is an optional iterable object that contains the
+   * initial elements to be added to the data structure. It defaults to an empty array if no elements
+   * are provided.
    */
   constructor(elements: Iterable<E> = []) {
     super();
@@ -49,29 +108,43 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
 
   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 {
     return this._head;
   }
 
   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 {
     return this._tail;
   }
 
   protected _size: number;
 
+  /**
+   * The function returns the size of an object.
+   * @returns The size of the object, which is a number.
+   */
   get size(): number {
     return this._size;
   }
 
   /**
-   * Time Complexity: O(n), where n is the size of the input array.
-   * Space Complexity: O(n)
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   * where n is the number of elements in the linked list.
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
    * The `get first` function returns the first node in a doubly linked list, or undefined if the list is empty.
@@ -87,7 +160,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(1)
    * Space Complexity: O(1)
    *
    * The `get last` function returns the last node in a doubly linked list, or undefined if the list is empty.
@@ -98,12 +171,12 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    */
 
   /**
-   * Time Complexity: O(n), where n is the size of the input array.
+   * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
    * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
@@ -112,11 +185,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    * @returns The `fromArray` function returns a DoublyLinkedList object.
    */
   static fromArray<E>(data: E[]) {
-    const doublyLinkedList = new DoublyLinkedList<E>();
-    for (const item of data) {
-      doublyLinkedList.push(item);
-    }
-    return doublyLinkedList;
+    return new DoublyLinkedList<E>(data);
   }
 
   /**
@@ -173,7 +242,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(1)
    * Space Complexity: O(1)
    */
 
@@ -200,7 +269,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(1)
    * Space Complexity: O(1)
    */
 
@@ -227,21 +296,21 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
-   * The `getAt` function returns the value at a specified index in a linked list, or undefined if the index is out of bounds.
+   * The `at` function returns the value at a specified index in a linked list, or undefined if the index is out of bounds.
    * @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 is returning the value at the specified index in the linked list. If the index is out of bounds
    * or the linked list is empty, it will return undefined.
    */
-  getAt(index: number): E | undefined {
+  at(index: number): E | undefined {
     if (index < 0 || index >= this.size) return undefined;
     let current = this.head;
     for (let i = 0; i < index; i++) {
@@ -251,12 +320,12 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
    * The function `getNodeAt` returns the node at a given index in a doubly linked list, or undefined if the index is out of
@@ -276,12 +345,12 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
    * The function `findNodeByValue` searches for a node with a specific value in a doubly linked list and returns the
@@ -304,12 +373,12 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
    * The `insert` function inserts a value at a specified index in a doubly linked list.
@@ -343,12 +412,13 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(1) or O(n)
    * Space Complexity: O(1)
+   * where n is the number of elements in the linked list.
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(1) or O(n)
    * Space Complexity: O(1)
    *
    * The `addBefore` function inserts a new value before an existing value or node in a doubly linked list.
@@ -388,12 +458,12 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(1) or O(n)
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(1) or O(n)
    * Space Complexity: O(1)
    *
    * The `addAfter` function inserts a new node with a given value after an existing node in a doubly linked list.
@@ -432,7 +502,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * 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.
@@ -462,7 +532,12 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(1) or O(n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(1) or O(n)
    * Space Complexity: O(1)
    *
    * The `delete` function removes a node from a doubly linked list based on either the node itself or its value.
@@ -498,11 +573,14 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(1)
    * Space Complexity: O(1)
    */
 
   /**
+   * 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.
    * @returns A boolean value is being returned.
    */
@@ -511,11 +589,14 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(1)
    * Space Complexity: O(1)
    */
 
   /**
+   * 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.
    */
   clear(): void {
@@ -525,38 +606,12 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(1)
-   */
-
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(1)
-   *
-   * 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 {
-    let current = this.head;
-    while (current) {
-      if (callback(current.value)) {
-        return current.value;
-      }
-      current = current.next;
-    }
-    return undefined;
-  }
-
-  /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
    * The function returns the index of the first occurrence of a given value in a linked list.
@@ -579,12 +634,12 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(n)
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
    * The `findBackward` function iterates through a linked list from the last node to the first node and returns the last
@@ -606,12 +661,12 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
-   * Space Complexity: O(n)
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(1)
    *
    * The `reverse` function reverses the order of the elements in a doubly linked list.
@@ -633,7 +688,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
    * The `toArray` function converts a linked list into an array.
@@ -650,12 +705,12 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(n)
    */
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
    * The `toReversedArray` function converts a doubly linked list into an array in reverse order.
@@ -672,8 +727,26 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   *
+   * The `clone` function creates a new instance of the `DoublyLinkedList` class with the same values
+   * as the original list.
+   * @returns The `clone()` method is returning a new instance of the `DoublyLinkedList` class, which
+   * is a copy of the original list.
+   */
+  clone(): DoublyLinkedList<E> {
+    return new DoublyLinkedList(this.values());
+  }
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    */
 
   /**
@@ -706,8 +779,8 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
    */
 
   /**
@@ -772,7 +845,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(1)
    * Space Complexity: O(1)
    */
 
@@ -789,7 +862,7 @@ export class DoublyLinkedList<E = any> extends IterableElementBase<E> {
   }
 
   /**
-   * Time Complexity: O(n), where n is the number of elements in the linked list.
+   * Time Complexity: O(1)
    * Space Complexity: O(1)
    */