data-structure-typed 1.15.2 → 1.17.0

package/README.md

@@ -15,6 +15,12 @@ Hash, Coordinate Set, Coordinate Map, Heap, Priority Queue, Max Priority Queue,
 
 # How
 
+[API Docs](https://data-structure-typed-docs.vercel.app)
+
+[Live Examples](https://data-structure-typed-examples.vercel.app)
+
+<a href="https://data-structure-typed-examples.vercel.app" target="_blank">Live Examples</a>
+
 ## install
 
 ### yarn
@@ -130,12 +136,6 @@ npm install data-structure-typed
     expect(bfsNodes[2].id).toBe(16);
 ```
 
-## Live Examples
-
-[//]: # ([Live Examples]&#40;https://data-structure-typed-examples.vercel.app&#41;)
-
-<a href="https://data-structure-typed-examples.vercel.app" target="_blank">Live Examples</a>
-
 ### Directed Graph simple snippet
 
 ```typescript
@@ -733,41 +733,41 @@ describe('DirectedGraph Test3', () => {
 </tbody>
 </table>
 
-![overview diagram](src/assets/overview-diagram-of-data-structures.png)
+![overview diagram](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/assets/overview-diagram-of-data-structures.png)
 
-![complexities](src/assets/complexities-diff.jpg)
+![complexities](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/assets/complexities-diff.jpg)
 
-![complexities of data structures](src/assets/data-structure-complexities.jpg)
+![complexities of data structures](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/assets/data-structure-complexities.jpg)
 
-![](src/data-structures/binary-tree/diagrams/bst-rotation.gif)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/binary-tree/bst-rotation.gif)
 
-![](src/data-structures/binary-tree/diagrams/avl-tree-inserting.gif)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/binary-tree/avl-tree-inserting.gif)
 
-![](src/data-structures/graph/diagrams/tarjan.webp)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/tarjan.webp)
 
-![](src/data-structures/graph/diagrams/adjacency-list.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-list.jpg)
 
-![](src/data-structures/graph/diagrams/adjacency-list-pros-cons.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-list-pros-cons.jpg)
 
-![](src/data-structures/graph/diagrams/adjacency-matrix.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-matrix.jpg)
 
-![](src/data-structures/graph/diagrams/adjacency-matrix-pros-cons.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/adjacency-matrix-pros-cons.jpg)
 
-![](src/data-structures/graph/diagrams/dfs-can-do.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/dfs-can-do.jpg)
 
-![](src/data-structures/graph/diagrams/edge-list.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/edge-list.jpg)
 
-![](src/data-structures/graph/diagrams/edge-list-pros-cons.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/edge-list-pros-cons.jpg)
 
-![](src/data-structures/graph/diagrams/max-flow.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/max-flow.jpg)
 
-![](src/data-structures/graph/diagrams/mst.jpg)
+![](https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/mst.jpg)
 
-[//]: # (![]&#40;src/data-structures/graph/diagrams/tarjan-articulation-point-bridge.png&#41;)
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/tarjan-articulation-point-bridge.png&#41;)
 
-[//]: # (![]&#40;src/data-structures/graph/diagrams/tarjan-complicate-simple.png&#41;)
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/tarjan-complicate-simple.png&#41;)
 
-[//]: # (![]&#40;src/data-structures/graph/diagrams/tarjan-strongly-connected-component.png&#41;)
+[//]: # (![]&#40;https://github.com/zrwusa/assets/blob/master/images/data-structure-typed/graph/tarjan-strongly-connected-component.png&#41;)
 
 
 

package/dist/data-structures/heap/heap.d.ts

@@ -6,8 +6,17 @@
  * @license MIT License
  */
 import { PriorityQueue } from '../priority-queue';
-import type { HeapItem, HeapOptions } from '../types';
-export declare abstract class Heap<T> {
+import type { HeapOptions } from '../types';
+export declare class HeapItem<T = number> {
+    constructor(priority?: number, val?: T | null);
+    private _priority;
+    get priority(): number;
+    set priority(value: number);
+    private _val;
+    get val(): T | null;
+    set val(value: T | null);
+}
+export declare abstract class Heap<T = number> {
     /**
      * The function is a constructor for a class that initializes a priority callback function based on the
      * options provided.
@@ -17,9 +26,9 @@ export declare abstract class Heap<T> {
     protected abstract _pq: PriorityQueue<HeapItem<T>>;
     get pq(): PriorityQueue<HeapItem<T>>;
     protected set pq(v: PriorityQueue<HeapItem<T>>);
-    protected _priorityCb: (element: T) => number;
-    get priorityCb(): (element: T) => number;
-    protected set priorityCb(v: (element: T) => number);
+    protected _priorityCb: (val: T) => number;
+    get priorityCb(): (val: T) => number;
+    protected set priorityCb(v: (val: T) => number);
     /**
      * The function returns the size of a priority queue.
      * @returns The size of the priority queue.
@@ -32,7 +41,7 @@ export declare abstract class Heap<T> {
     /**
      * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
      */
-    getPriorityCb(): (element: T) => number;
+    getPriorityCb(): (val: T) => number;
     /**
      * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
      */
@@ -44,33 +53,39 @@ export declare abstract class Heap<T> {
     isEmpty(): boolean;
     /**
      * The `peek` function returns the top item in the priority queue without removing it.
-     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an element with the highest priority in the queue
+     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an val with the highest priority in the queue
      */
     peek(): HeapItem<T> | null;
     /**
      * The `peekLast` function returns the last item in the heap.
-     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an element with the lowest priority in the queue
+     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an val with the lowest priority in the queue
      */
     peekLast(): HeapItem<T> | null;
     /**
-     * The `add` function adds an element to a priority queue with an optional priority value.
-     * @param {T} element - The `element` parameter represents the value that you want to add to the heap. It can be of any
+     * The `add` function adds an val to a priority queue with an optional priority value.
+     * @param {T} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
      * type.
      * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
-     * element being added to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
-     * the value of `element`. If the `element` parameter is not a number, then the
+     * val being added to the heap. If the `val` parameter is a number, then the `priority` parameter is set to
+     * the value of `val`. If the `val` parameter is not a number, then the
      * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    add(element: T, priority?: number): Heap<T>;
+    add(val: T, priority?: number): Heap<T>;
     /**
-     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an element with the highest priority in the queue
+     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an val with the highest priority in the queue
      * @returns either a HeapItem<T> object or null.
      */
     poll(): HeapItem<T> | null;
+    /**
+     * The function checks if a given node or value exists in the priority queue.
+     * @param {T | HeapItem<T>} node - The parameter `node` can be of type `T` or `HeapItem<T>`.
+     * @returns a boolean value.
+     */
+    has(node: T | HeapItem<T>): boolean;
     /**
      * The `toArray` function returns an array of `HeapItem<T>` objects.
-     * @returns An array of HeapItem<T> objects.Returns a sorted list of elements
+     * @returns An array of HeapItem<T> objects.Returns a sorted list of vals
      */
     toArray(): HeapItem<T>[];
     /**

package/dist/data-structures/heap/heap.js

@@ -1,6 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Heap = void 0;
+exports.Heap = exports.HeapItem = void 0;
+var HeapItem = /** @class */ (function () {
+    function HeapItem(priority, val) {
+        if (priority === void 0) { priority = NaN; }
+        if (val === void 0) { val = null; }
+        this._val = val;
+        this._priority = priority;
+    }
+    Object.defineProperty(HeapItem.prototype, "priority", {
+        get: function () {
+            return this._priority;
+        },
+        set: function (value) {
+            this._priority = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(HeapItem.prototype, "val", {
+        get: function () {
+            return this._val;
+        },
+        set: function (value) {
+            this._val = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return HeapItem;
+}());
+exports.HeapItem = HeapItem;
 var Heap = /** @class */ (function () {
     /**
      * The function is a constructor for a class that initializes a priority callback function based on the
@@ -77,31 +107,31 @@ var Heap = /** @class */ (function () {
     };
     /**
      * The `peek` function returns the top item in the priority queue without removing it.
-     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an element with the highest priority in the queue
+     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an val with the highest priority in the queue
      */
     Heap.prototype.peek = function () {
         return this._pq.peek();
     };
     /**
      * The `peekLast` function returns the last item in the heap.
-     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an element with the lowest priority in the queue
+     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an val with the lowest priority in the queue
      */
     Heap.prototype.peekLast = function () {
         return this._pq.leaf();
     };
     /**
-     * The `add` function adds an element to a priority queue with an optional priority value.
-     * @param {T} element - The `element` parameter represents the value that you want to add to the heap. It can be of any
+     * The `add` function adds an val to a priority queue with an optional priority value.
+     * @param {T} val - The `val` parameter represents the value that you want to add to the heap. It can be of any
      * type.
      * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
-     * element being added to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
-     * the value of `element`. If the `element` parameter is not a number, then the
+     * val being added to the heap. If the `val` parameter is a number, then the `priority` parameter is set to
+     * the value of `val`. If the `val` parameter is not a number, then the
      * @returns The `add` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
-    Heap.prototype.add = function (element, priority) {
-        if (typeof element === 'number') {
-            priority = element;
+    Heap.prototype.add = function (val, priority) {
+        if (typeof val === 'number') {
+            priority = val;
         }
         else {
             if (priority === undefined) {
@@ -111,16 +141,16 @@ var Heap = /** @class */ (function () {
         if (priority && Number.isNaN(+priority)) {
             throw new Error('.add expects a numeric priority');
         }
-        if (Number.isNaN(+priority) && Number.isNaN(this._priorityCb(element))) {
+        if (Number.isNaN(+priority) && Number.isNaN(this._priorityCb(val))) {
             throw new Error('.add expects a numeric priority '
                 + 'or a constructor callback that returns a number');
         }
-        var _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(element);
-        this._pq.add({ priority: _priority, element: element });
+        var _priority = !Number.isNaN(+priority) ? priority : this._priorityCb(val);
+        this._pq.add(new HeapItem(_priority, val));
         return this;
     };
     /**
-     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an element with the highest priority in the queue
+     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an val with the highest priority in the queue
      * @returns either a HeapItem<T> object or null.
      */
     Heap.prototype.poll = function () {
@@ -130,9 +160,24 @@ var Heap = /** @class */ (function () {
         }
         return top;
     };
+    /**
+     * The function checks if a given node or value exists in the priority queue.
+     * @param {T | HeapItem<T>} node - The parameter `node` can be of type `T` or `HeapItem<T>`.
+     * @returns a boolean value.
+     */
+    Heap.prototype.has = function (node) {
+        if (node instanceof (HeapItem)) {
+            return this.getPq().getNodes().includes(node);
+        }
+        else {
+            return this.getPq().getNodes().findIndex(function (item) {
+                return item.val === node;
+            }) !== -1;
+        }
+    };
     /**
      * The `toArray` function returns an array of `HeapItem<T>` objects.
-     * @returns An array of HeapItem<T> objects.Returns a sorted list of elements
+     * @returns An array of HeapItem<T> objects.Returns a sorted list of vals
      */
     Heap.prototype.toArray = function () {
         return this._pq.toArray();

package/dist/data-structures/heap/max-heap.d.ts

@@ -5,14 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { Heap } from './heap';
+import { Heap, HeapItem } from './heap';
 import { PriorityQueue } from '../priority-queue';
-import type { HeapItem, HeapOptions } from '../types';
+import type { HeapOptions } from '../types';
 /**
  * @class MaxHeap
  * @extends Heap
  */
-export declare class MaxHeap<T> extends Heap<T> {
+export declare class MaxHeap<T = number> extends Heap<T> {
     protected _pq: PriorityQueue<HeapItem<T>>;
     /**
      * The constructor initializes a PriorityQueue with a custom comparator function.

package/dist/data-structures/heap/min-heap.d.ts

@@ -5,14 +5,14 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { Heap } from './heap';
+import { Heap, HeapItem } from './heap';
 import { PriorityQueue } from '../priority-queue';
-import type { HeapItem, HeapOptions } from '../types';
+import type { HeapOptions } from '../types';
 /**
  * @class MinHeap
  * @extends Heap
  */
-export declare class MinHeap<T> extends Heap<T> {
+export declare class MinHeap<T = number> extends Heap<T> {
     protected _pq: PriorityQueue<HeapItem<T>>;
     /**
      * The constructor initializes a PriorityQueue with a comparator function that compares the priority of two HeapItem

package/dist/data-structures/index.d.ts

@@ -4,6 +4,7 @@ export * from './stack';
 export * from './queue';
 export * from './graph';
 export * from './binary-tree';
+export * from './tree';
 export * from './heap';
 export * from './priority-queue';
 export * from './matrix';

package/dist/data-structures/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./stack"), exports);
 __exportStar(require("./queue"), exports);
 __exportStar(require("./graph"), exports);
 __exportStar(require("./binary-tree"), exports);
+__exportStar(require("./tree"), exports);
 __exportStar(require("./heap"), exports);
 __exportStar(require("./priority-queue"), exports);
 __exportStar(require("./matrix"), exports);

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

@@ -1,89 +1,216 @@
-export declare class DoublyLinkedListNode<T> {
-    constructor(nodeValue: T);
-    protected _val: T;
+/**
+ * data-structure-typed
+ *
+ * @author Tyler Zeng
+ * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT License
+ */
+export declare class DoublyLinkedListNode<T = number> {
+    /**
+     * The constructor function initializes the value, next, and previous properties of an object.
+     * @param {T} val - The "val" 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 "T".
+     */
+    constructor(val: T);
+    private _val;
     get val(): T;
-    set val(v: T);
-    protected _next: DoublyLinkedListNode<T> | null;
+    set val(value: T);
+    private _next;
     get next(): DoublyLinkedListNode<T> | null;
-    set next(v: DoublyLinkedListNode<T> | null);
-    protected _prev: DoublyLinkedListNode<T> | null;
+    set next(value: DoublyLinkedListNode<T> | null);
+    private _prev;
     get prev(): DoublyLinkedListNode<T> | null;
-    set prev(v: DoublyLinkedListNode<T> | null);
+    set prev(value: DoublyLinkedListNode<T> | null);
 }
 export declare class DoublyLinkedList<T> {
+    /**
+     * The constructor initializes the linked list with an empty head, tail, and length.
+     */
     constructor();
-    protected _first: DoublyLinkedListNode<T> | null;
-    get first(): DoublyLinkedListNode<T> | null;
-    protected set first(v: DoublyLinkedListNode<T> | null);
-    protected _last: DoublyLinkedListNode<T> | null;
-    get last(): DoublyLinkedListNode<T> | null;
-    protected set last(v: DoublyLinkedListNode<T> | null);
-    protected _size: number;
-    get size(): number;
-    protected set size(v: number);
+    private _head;
+    get head(): DoublyLinkedListNode<T> | null;
+    set head(value: DoublyLinkedListNode<T> | null);
+    private _tail;
+    get tail(): DoublyLinkedListNode<T> | null;
+    set tail(value: DoublyLinkedListNode<T> | null);
+    private _length;
+    get length(): number;
+    protected set length(value: number);
     /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     * The `fromArray` function creates a new instance of a DoublyLinkedList and populates it with the elements from the
+     * given array.
+     * @param {T[]} data - The `data` parameter is an array of elements of type `T`.
+     * @returns The `fromArray` function returns a DoublyLinkedList object.
      */
-    getFirst(): DoublyLinkedListNode<T> | null;
+    static fromArray<T>(data: T[]): DoublyLinkedList<T>;
+    getLength(): number;
     /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     * The push function adds a new node with the given value to the end of the doubly linked list.
+     * @param {T} val - The value to be added to the linked list.
      */
-    getLast(): DoublyLinkedListNode<T> | null;
+    push(val: T): void;
     /**
-     * Starting from TypeScript version 5.0 and onwards, the use of distinct access modifiers for Getters and Setters is not permitted. As an alternative, to ensure compatibility, it is necessary to adopt a Java-style approach for Setters (using the same name as the property) while utilizing separate method names for Getters.
+     * The `pop()` function removes and returns the value of the last node in a doubly linked list.
+     * @returns The method is returning the value of the removed node (removedNode.val) if the list is not empty. If the
+     * list is empty, it returns null.
      */
-    getSize(): number;
+    pop(): T | null;
     /**
-     * The function adds a new node with a given value to the beginning of a doubly linked list.
-     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the beginning of
-     * the doubly linked list.
-     * @returns A boolean value is being returned.
+     * The `shift()` function removes and returns the value of the first node in a doubly linked list.
+     * @returns The method `shift()` returns the value of the node that is removed from the beginning of the doubly linked
+     * list.
      */
-    addFirst(val: T): boolean;
+    shift(): T | null;
     /**
-     * The function adds a new node with a given value to the end of a doubly linked list.
-     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the end of the
+     * The unshift function adds a new node with the given value to the beginning of a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value of the new node that will be added to the beginning of the
      * doubly linked list.
-     * @returns a boolean value, which is always true.
-     */
-    addLast(val: T): boolean;
-    peekFirst(): T | null;
-    peekFirst(by: 'val'): T | null;
-    peekFirst(by: 'node'): DoublyLinkedListNode<T> | null;
-    peekLast(): T | null;
-    peekLast(by: 'val'): T | null;
-    peekLast(by: 'node'): DoublyLinkedListNode<T> | null;
-    pollFirst(): T | null;
-    pollFirst(by: 'val'): T | null;
-    pollFirst(by: 'node'): DoublyLinkedListNode<T> | null;
-    pollLast(): T | null;
-    pollLast(by: 'val'): T | null;
-    pollLast(by: 'node'): DoublyLinkedListNode<T> | null;
-    get(index: number): T | null;
-    get(index: number, by: 'node'): DoublyLinkedListNode<T> | null;
-    get(index: number, by: 'val'): T | null;
-    /**
-     * Updates the value of the node at the specified index.
-     * If index = 0; Value of the first element in the list is updated.
-     * If index = 3; Value of the fourth element in the list is updated.
-     * @param index Index of the node to be updated
-     * @param val New value of the node
-     */
-    set(index: number, val: T): boolean;
-    isEmpty(): boolean;
-    /**
-     * Inserts a new node at the specified index.
-     * @param index Index at which the new node has to be inserted
-     * @param val Value of the new node to be inserted
      */
-    insert(index: number, val: T): boolean;
+    unshift(val: T): void;
+    /**
+     * The `getAt` function returns the value at a specified index in a linked list, or null 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 null.
+     */
+    getAt(index: number): T | null;
+    /**
+     * The function `getNodeAt` returns the node at a given index in a doubly 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 node we want to
+     * retrieve from the doubly linked list. It indicates the zero-based index of the node we want to access.
+     * @returns The method `getNodeAt(index: number)` returns a `DoublyLinkedListNode<T>` object if the index is within the
+     * valid range of the linked list, otherwise it returns `null`.
+     */
+    getNodeAt(index: number): DoublyLinkedListNode<T> | null;
+    /**
+     * The function `findNodeByValue` searches for a node with a specific value in a doubly linked list and returns the
+     * node if found, otherwise it returns null.
+     * @param {T} val - The `val` parameter is the value that we want to search for in the doubly linked list.
+     * @returns The function `findNodeByValue` returns a `DoublyLinkedListNode<T>` if a node with the specified value `val`
+     * is found in the linked list. If no such node is found, it returns `null`.
+     */
+    findNode(val: T): DoublyLinkedListNode<T> | null;
     /**
-     * The `remove` function removes an element at a specified index from a data structure, updating the links between
-     * nodes accordingly.
-     * @param {number} index - The index parameter represents the position of the element to be removed in the data
-     * structure. It is of type number.
-     * @returns The `remove` method returns the value of the removed element (`T`) if the removal is successful, or `null`
+     * The `insert` function inserts a value at a specified index in a doubly linked list.
+     * @param {number} index - The index parameter represents the position at which the new value should be inserted in the
+     * DoublyLinkedList. It is of type number.
+     * @param {T} val - The `val` parameter represents the value that you want to insert into the Doubly Linked List at the
+     * specified index.
+     * @returns The `insert` method returns a boolean value. It returns `true` if the insertion is successful, and `false`
      * if the index is out of bounds.
      */
-    remove(index: number): T | null;
+    insert(index: number, val: T): boolean;
+    /**
+     * 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.
+     * @returns The method `deleteAt` returns the value of the node that was deleted, or `null` if the index is out of
+     * bounds.
+     */
+    deleteAt(index: number): T | null;
+    /**
+     * The `delete` function removes a node with a specific value from a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value that you want to delete from the linked list.
+     * @returns The `delete` method returns a boolean value. It returns `true` if the value `val` is found and deleted from
+     * the linked list, and `false` if the value is not found in the linked list.
+     */
+    delete(val: T): boolean;
+    /**
+     * The `toArray` function converts a linked list into an array.
+     * @returns The `toArray()` method is returning an array of type `T[]`.
+     */
+    toArray(): T[];
+    /**
+     * The `clear` function resets the linked list by setting the head, tail, and length to null and 0 respectively.
+     */
+    clear(): void;
+    /**
+     * 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 T 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 `null`.
+     */
+    find(callback: (val: T) => boolean): T | null;
+    /**
+     * The function returns the index of the first occurrence of a given value in a linked list.
+     * @param {T} val - The parameter `val` is of type `T`, which means it can be any data type. It represents the value
+     * that we are searching for in the linked list.
+     * @returns The method `indexOf` returns the index of the first occurrence of the specified value `val` in the linked
+     * list. If the value is not found, it returns -1.
+     */
+    indexOf(val: T): number;
+    /**
+     * The `findLast` function iterates through a linked list from the last node to the first node and returns the last
+     * value that satisfies the given callback function, or null if no value satisfies the callback.
+     * @param callback - A function that takes a value of type T as its parameter and returns a boolean value. This
+     * function is used to determine whether a given value satisfies a certain condition.
+     * @returns The method `findLast` returns the last value in the linked list that satisfies the condition specified by
+     * the callback function. If no value satisfies the condition, it returns `null`.
+     */
+    findLast(callback: (val: T) => boolean): T | null;
+    /**
+     * The `toArrayReverse` function converts a doubly linked list into an array in reverse order.
+     * @returns The `toArrayReverse()` function returns an array of type `T[]`.
+     */
+    toArrayReverse(): T[];
+    /**
+     * The `reverse` function reverses the order of the elements in a doubly linked list.
+     */
+    reverse(): void;
+    /**
+     * 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: val and index. The val argument
+     * represents the value of the current node in the linked list, and the index argument represents the index of the
+     * current node in the linked list.
+     */
+    forEach(callback: (val: T, index: number) => void): void;
+    /**
+     * The `map` function takes a callback function and applies it to each element in the DoublyLinkedList, returning a new
+     * DoublyLinkedList with the transformed values.
+     * @param callback - The callback parameter is a function that takes a value of type T (the type of values stored in
+     * the original DoublyLinkedList) and returns a value of type U (the type of values that will be stored in the mapped
+     * DoublyLinkedList).
+     * @returns The `map` function is returning a new instance of `DoublyLinkedList<U>` that contains the mapped values.
+     */
+    map<U>(callback: (val: T) => U): DoublyLinkedList<U>;
+    /**
+     * The `filter` function iterates through a DoublyLinkedList and returns a new DoublyLinkedList containing only the
+     * elements that satisfy the given callback function.
+     * @param callback - The `callback` parameter is a function that takes a value of type `T` and returns a boolean value.
+     * It is used to determine whether a value should be included in the filtered list or not.
+     * @returns The filtered list, which is an instance of the DoublyLinkedList class.
+     */
+    filter(callback: (val: T) => boolean): DoublyLinkedList<T>;
+    /**
+     * 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 `val`. It is
+     * used to perform a specific operation on each element of the linked list.
+     * @param {U} initialValue - The `initialValue` parameter is the initial value of the accumulator. It is the starting
+     * point for the reduction operation.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating through all the
+     * elements in the linked list.
+     */
+    reduce<U>(callback: (accumulator: U, val: T) => U, initialValue: U): U;
+    /**
+     * The function inserts a new value after an existing value in a doubly linked list.
+     * @param {T} existingValue - The existing value is the value of the node after which we want to insert the new value.
+     * @param {T} newValue - The `newValue` parameter represents the value of the new node that you want to insert after
+     * the existing node.
+     * @returns The method is returning a boolean value. It returns true if the insertion is successful and false if the
+     * existing value is not found in the linked list.
+     */
+    insertAfter(existingValue: T, newValue: T): boolean;
+    /**
+     * The `insertBefore` function inserts a new value before an existing value in a doubly linked list.
+     * @param {T} existingValue - The existing value is the value of the node that you want to insert the new value before.
+     * @param {T} newValue - The `newValue` parameter represents the value of the new node that you want to insert before
+     * the existing node.
+     * @returns The method is returning a boolean value. It returns true if the insertion is successful and false if the
+     * existing value is not found in the linked list.
+     */
+    insertBefore(existingValue: T, newValue: T): boolean;
 }