Class DoublyLinkedList<E, R>

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.
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.
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.
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 = [
      { type: 'insert', content: 'first line of text' },
      { type: 'insert', content: 'second line of text' },
      { type: 'delete', content: 'delete the first line' }
    ];
    const editorHistory = new DoublyLinkedList<{ type: string; content: string }>(actions);

    console.log(editorHistory.last?.type); // 'delete'
    console.log(editorHistory.pop()?.content); // 'delete the first line'
    console.log(editorHistory.last?.type); // 'insert'

Example

// Browser history
    const browserHistory = new DoublyLinkedList<string>();

    browserHistory.push('home page');
    browserHistory.push('search page');
    browserHistory.push('details page');

    console.log(browserHistory.last); // 'details page'
    console.log(browserHistory.pop()); // 'details page'
    console.log(browserHistory.last); // 'search page'

Example

// Use DoublyLinkedList to implement music player
    // Define the Song interface
    interface Song {
      title: string;
      artist: string;
      duration: number; // duration in seconds
    }

    class Player {
      private playlist: DoublyLinkedList<Song>;
      private currentSong: ReturnType<typeof this.playlist.getNodeAt> | undefined;

      constructor(songs: Song[]) {
        this.playlist = new DoublyLinkedList<Song>();
        songs.forEach(song => this.playlist.push(song));
        this.currentSong = this.playlist.head;
      }

      // Play the next song in the playlist
      playNext(): Song | undefined {
        if (!this.currentSong?.next) {
          this.currentSong = this.playlist.head; // Loop to the first song
        } else {
          this.currentSong = this.currentSong.next;
        }
        return this.currentSong?.value;
      }

      // Play the previous song in the playlist
      playPrevious(): Song | undefined {
        if (!this.currentSong?.prev) {
          this.currentSong = this.playlist.tail; // Loop to the last song
        } else {
          this.currentSong = this.currentSong.prev;
        }
        return this.currentSong?.value;
      }

      // Get the current song
      getCurrentSong(): Song | undefined {
        return this.currentSong?.value;
      }

      // Loop through the playlist twice
      loopThroughPlaylist(): Song[] {
        const playedSongs: Song[] = [];
        const initialNode = this.currentSong;

        // Loop through the playlist twice
        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
        }

        // Reset the current song to the initial song
        this.currentSong = initialNode;
        return playedSongs;
      }
    }

    const songs = [
      { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 },
      { title: 'Hotel California', artist: 'Eagles', duration: 391 },
      { title: 'Shape of You', artist: 'Ed Sheeran', duration: 233 },
      { title: 'Billie Jean', artist: 'Michael Jackson', duration: 294 }
    ];
    let player = new Player(songs);
    // should play the next song
    player = new Player(songs);
    const firstSong = player.getCurrentSong();
    const nextSong = player.playNext();

    // Expect the next song to be "Hotel California by Eagles"
    console.log(nextSong); // { title: 'Hotel California', artist: 'Eagles', duration: 391 }
    console.log(firstSong); // { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 }

    // should play the previous song
    player = new Player(songs);
    player.playNext(); // Move to the second song
    const currentSong = player.getCurrentSong();
    const previousSong = player.playPrevious();

    // Expect the previous song to be "Bohemian Rhapsody by Queen"
    console.log(previousSong); // { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 }
    console.log(currentSong); // { title: 'Hotel California', artist: 'Eagles', duration: 391 }

    // should loop to the first song when playing next from the last song
    player = new Player(songs);
    player.playNext(); // Move to the second song
    player.playNext(); // Move to the third song
    player.playNext(); // Move to the fourth song

    const nextSongToFirst = player.playNext(); // Should loop to the first song

    // Expect the next song to be "Bohemian Rhapsody by Queen"
    console.log(nextSongToFirst); // { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 }

    // should loop to the last song when playing previous from the first song
    player = new Player(songs);
    player.playNext(); // Move to the first song
    player.playNext(); // Move to the second song
    player.playNext(); // Move to the third song
    player.playNext(); // Move to the fourth song

    const previousToLast = player.playPrevious(); // Should loop to the last song

    // Expect the previous song to be "Billie Jean by Michael Jackson"
    console.log(previousToLast); // { title: 'Billie Jean', artist: 'Michael Jackson', duration: 294 }

    // should loop through the entire playlist
    player = new Player(songs);
    const playedSongs = player.loopThroughPlaylist();

    // The expected order of songs for two loops
    console.log(playedSongs); // [
 //      { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 },
 //      { title: 'Hotel California', artist: 'Eagles', duration: 391 },
 //      { title: 'Shape of You', artist: 'Ed Sheeran', duration: 233 },
 //      { title: 'Billie Jean', artist: 'Michael Jackson', duration: 294 },
 //      { title: 'Bohemian Rhapsody', artist: 'Queen', duration: 354 },
 //      { title: 'Hotel California', artist: 'Eagles', duration: 391 },
 //      { title: 'Shape of You', artist: 'Ed Sheeran', duration: 233 },
 //      { title: 'Billie Jean', artist: 'Michael Jackson', duration: 294 }
 //    ]

Example

// Use DoublyLinkedList to implement LRU cache
    interface CacheEntry<K, V> {
      key: K;
      value: V;
    }

    class LRUCache<K = string, V = any> {
      private readonly capacity: number;
      private list: DoublyLinkedList<CacheEntry<K, V>>;
      private map: Map<K, DoublyLinkedListNode<CacheEntry<K, V>>>;

      constructor(capacity: number) {
        if (capacity <= 0) {
          throw new Error('lru cache capacity must be greater than 0');
        }
        this.capacity = capacity;
        this.list = new DoublyLinkedList<CacheEntry<K, V>>();
        this.map = new Map<K, DoublyLinkedListNode<CacheEntry<K, V>>>();
      }

      // Get cached value
      get(key: K): V | undefined {
        const node = this.map.get(key);

        if (!node) return undefined;

        // Move the visited node to the head of the linked list (most recently used)
        this.moveToFront(node);

        return node.value.value;
      }

      // Set cache value
      set(key: K, value: V): void {
        // Check if it already exists
        const node = this.map.get(key);

        if (node) {
          // Update value and move to head
          node.value.value = value;
          this.moveToFront(node);
          return;
        }

        // Check 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) {
            this.map.delete(removedNode.value.key);
            this.list.pop();
          }
        }

        // Create new node and add to head
        const newEntry: CacheEntry<K, V> = { key, value };
        this.list.unshift(newEntry);

        // Save node reference in map
        const newNode = this.list.head;
        if (newNode) {
          this.map.set(key, newNode);
        }
      }

      // Move the node to the head of the linked list
      private moveToFront(node: DoublyLinkedListNode<CacheEntry<K, V>>): void {
        this.list.delete(node);
        this.list.unshift(node.value);
      }

      // Delete specific key
      delete(key: K): boolean {
        const node = this.map.get(key);
        if (!node) return false;

        // Remove from linked list
        this.list.delete(node);
        // Remove from map
        this.map.delete(key);

        return true;
      }

      // Clear cache
      clear(): void {
        this.list.clear();
        this.map.clear();
      }

      // Get the current cache length
      get length(): number {
        return this.list.length;
      }

      // Check if it is empty
      get isEmpty(): boolean {
        return this.list.isEmpty();
      }
    }

    // should set and get values correctly
    const cache = new LRUCache<string, number>(3);
    cache.set('a', 1);
    cache.set('b', 2);
    cache.set('c', 3);

    console.log(cache.get('a')); // 1
    console.log(cache.get('b')); // 2
    console.log(cache.get('c')); // 3

    // The least recently used element should be evicted when capacity is exceeded
    cache.clear();
    cache.set('a', 1);
    cache.set('b', 2);
    cache.set('c', 3);
    cache.set('d', 4); // This will eliminate 'a'

    console.log(cache.get('a')); // undefined
    console.log(cache.get('b')); // 2
    console.log(cache.get('c')); // 3
    console.log(cache.get('d')); // 4

    // The priority of an element should be updated when it is accessed
    cache.clear();
    cache.set('a', 1);
    cache.set('b', 2);
    cache.set('c', 3);

    cache.get('a'); // access 'a'
    cache.set('d', 4); // This will eliminate 'b'

    console.log(cache.get('a')); // 1
    console.log(cache.get('b')); // undefined
    console.log(cache.get('c')); // 3
    console.log(cache.get('d')); // 4

    // Should support updating existing keys
    cache.clear();
    cache.set('a', 1);
    cache.set('a', 10);

    console.log(cache.get('a')); // 10

    // Should support deleting specified keys
    cache.clear();
    cache.set('a', 1);
    cache.set('b', 2);

    console.log(cache.delete('a')); // true
    console.log(cache.get('a')); // undefined
    console.log(cache.length); // 1

    // Should support clearing cache
    cache.clear();
    cache.set('a', 1);
    cache.set('b', 2);
    cache.clear();

    console.log(cache.length); // 0
    console.log(cache.isEmpty); // true

Example

// finding lyrics by timestamp in Coldplay's "Fix You"
    // Create a DoublyLinkedList to store song lyrics with timestamps
    const lyricsList = new DoublyLinkedList<{ time: number; text: string }>();

    // Detailed lyrics with precise timestamps (in milliseconds)
    const lyrics = [
      { time: 0, text: "When you try your best, but you don't succeed" },
      { time: 4000, text: 'When you get what you want, but not what you need' },
      { time: 8000, text: "When you feel so tired, but you can't sleep" },
      { time: 12000, text: 'Stuck in reverse' },
      { time: 16000, text: 'And the tears come streaming down your face' },
      { time: 20000, text: "When you lose something you can't replace" },
      { time: 24000, text: 'When you love someone, but it goes to waste' },
      { time: 28000, text: 'Could it be worse?' },
      { time: 32000, text: 'Lights will guide you home' },
      { time: 36000, text: 'And ignite your bones' },
      { time: 40000, text: 'And I will try to fix you' }
    ];

    // Populate the DoublyLinkedList with lyrics
    lyrics.forEach(lyric => lyricsList.push(lyric));

    // Test different scenarios of lyric synchronization

    // 1. Find lyric at exact timestamp
    const exactTimeLyric = lyricsList.getBackward(lyric => lyric.value.time <= 36000);
    console.log(exactTimeLyric?.text); // 'And ignite your bones'

    // 2. Find lyric between timestamps
    const betweenTimeLyric = lyricsList.getBackward(lyric => lyric.value.time <= 22000);
    console.log(betweenTimeLyric?.text); // "When you lose something you can't replace"

    // 3. Find first lyric when timestamp is less than first entry
    const earlyTimeLyric = lyricsList.getBackward(lyric => lyric.value.time <= -1000);
    console.log(earlyTimeLyric); // undefined

    // 4. Find last lyric when timestamp is after last entry
    const lateTimeLyric = lyricsList.getBackward(lyric => lyric.value.time <= 50000);
    console.log(lateTimeLyric?.text); // 'And I will try to fix you'

Example

// cpu process schedules
    class Process {
      constructor(
        public id: number,
        public priority: number
      ) {}

      execute(): string {
        return `Process ${this.id} executed.`;
      }
    }

    class Scheduler {
      private queue: DoublyLinkedList<Process>;

      constructor() {
        this.queue = new DoublyLinkedList<Process>();
      }

      addProcess(process: Process): void {
        // Insert processes into a queue based on priority, keeping priority in descending order
        let current = this.queue.head;
        while (current && current.value.priority >= process.priority) {
          current = current.next;
        }

        if (!current) {
          this.queue.push(process);
        } else {
          this.queue.addBefore(current, process);
        }
      }

      executeNext(): string | undefined {
        // Execute tasks at the head of the queue in order
        const process = this.queue.shift();
        return process ? process.execute() : undefined;
      }

      listProcesses(): string[] {
        return this.queue.toArray().map(process => `Process ${process.id} (Priority: ${process.priority})`);
      }

      clear(): void {
        this.queue.clear();
      }
    }

    // should add processes based on priority
    let scheduler = new Scheduler();
    scheduler.addProcess(new Process(1, 10));
    scheduler.addProcess(new Process(2, 20));
    scheduler.addProcess(new Process(3, 15));

    console.log(scheduler.listProcesses()); // [
 //      'Process 2 (Priority: 20)',
 //      'Process 3 (Priority: 15)',
 //      'Process 1 (Priority: 10)'
 //    ]

    // should execute the highest priority process
    scheduler = new Scheduler();
    scheduler.addProcess(new Process(1, 10));
    scheduler.addProcess(new Process(2, 20));

    console.log(scheduler.executeNext()); // 'Process 2 executed.'
    console.log(scheduler.listProcesses()); // ['Process 1 (Priority: 10)']

    // should clear all processes
    scheduler = new Scheduler();
    scheduler.addProcess(new Process(1, 10));
    scheduler.addProcess(new Process(2, 20));

    scheduler.clear();
    console.log(scheduler.listProcesses()); // []

Type Parameters

E = any
R = any

Hierarchy

LinearLinkedBase<E, R, DoublyLinkedListNode<E>>
- DoublyLinkedList

Constructors

constructor

new DoublyLinkedList<E, R>(elements?, options?): DoublyLinkedList<E, R>
This TypeScript constructor initializes a DoublyLinkedList with optional elements and options.
Type Parameters
- E = any
- R = any
Parameters
- elements: Iterable<E, any, any> | Iterable<R, any, any> | Iterable<DoublyLinkedListNode<E>, any, any> = []
  The elements parameter in the constructor is an iterable collection of elements of type E or R. It is used to initialize the DoublyLinkedList with the elements provided in the iterable. If no elements are provided, the default value is an empty iterable.
- Optionaloptions: DoublyLinkedListOptions<E, R>
  The options parameter in the constructor is of type DoublyLinkedListOptions<E, R>. It is an optional parameter that allows you to pass additional configuration options to customize the behavior of the DoublyLinkedList.
Returns DoublyLinkedList<E, R>
Overrides LinearLinkedBase<E, R, DoublyLinkedListNode<E>>.constructor
- Defined in linked-list/doubly-linked-list.ts:489

Accessors

first

get first(): undefined | E
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.

Returns undefined | E
The method get first() returns the first node of the doubly linked list, or undefined if the list is empty.
- Defined in linked-list/doubly-linked-list.ts:531

last

get last(): undefined | E
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.

Returns undefined | E
The method get last() returns the last node of the doubly linked list, or undefined if the list is empty.
- Defined in linked-list/doubly-linked-list.ts:542

Methods

`Protected`_createInstance

_createInstance(options?): this
The function _createInstance returns a new instance of DoublyLinkedList with the specified options.
Parameters
- Optionaloptions: DoublyLinkedListOptions<E, R>
  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 this
An instance of the DoublyLinkedList class with an empty array and the provided options is being returned, cast as the current class type.
Overrides LinearLinkedBase._createInstance
- Defined in linked-list/doubly-linked-list.ts:1296

`Protected`_ensureNode

_ensureNode(elementOrNode): DoublyLinkedListNode<E>
The function _ensureNode ensures that the input is a valid node in a doubly linked list.
Parameters
- elementOrNode: E | DoublyLinkedListNode<E>
  The elementOrNode parameter can be either an element of type E or a DoublyLinkedListNode containing an element of type E.
Returns DoublyLinkedListNode<E>
If the elementOrNode parameter is already a DoublyLinkedListNode, it will be returned as is. Otherwise, a new DoublyLinkedListNode instance will be created with the elementOrNode value and returned.
- Defined in linked-list/doubly-linked-list.ts:1262

`Protected`_ensurePredicate

_ensurePredicate(elementNodeOrPredicate): ((node: DoublyLinkedListNode<E>) => boolean)
The function _ensurePredicate in TypeScript ensures that the input is either a node, a predicate function, or a value to compare with the node's value.
Parameters
- elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)
  elementNodeOrPredicate - The elementNodeOrPredicate parameter can be one of the following types:
Returns ((node: DoublyLinkedListNode<E>) => boolean)
A function is being returned that takes a DoublyLinkedListNode as a parameter and returns a boolean value based on the conditions specified in the code.
- - (node): boolean
  - Parameters
    - node: DoublyLinkedListNode<E>
    Returns boolean
- Defined in linked-list/doubly-linked-list.ts:1277

`Protected`_getIterator

_getIterator(): IterableIterator<E, any, any>
The function returns an iterator that iterates over the values of a linked list.

Returns IterableIterator<E, any, any>
Overrides LinearLinkedBase._getIterator
- Defined in linked-list/doubly-linked-list.ts:1195

`Protected`_getNodeIterator

_getNodeIterator(): IterableIterator<DoublyLinkedListNode<E>, any, any>
The function returns an iterator that iterates over the nodes of a doubly linked list starting from the head.

Returns IterableIterator<DoublyLinkedListNode<E>, any, any>
Overrides LinearLinkedBase._getNodeIterator
- Defined in linked-list/doubly-linked-list.ts:1221

`Protected`_getPrevNode

_getPrevNode(node): undefined | DoublyLinkedListNode<E>
The function _getPrevNode returns the previous node of a given node in a doubly linked list.
Parameters
- node: DoublyLinkedListNode<E>
  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 undefined | DoublyLinkedListNode<E>
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.
Overrides LinearLinkedBase._getPrevNode
- Defined in linked-list/doubly-linked-list.ts:1309

`Protected`_getReverseIterator

_getReverseIterator(): IterableIterator<E, any, any>
The function returns an iterator that iterates over the elements of a data structure in reverse order.

Returns IterableIterator<E, any, any>
Overrides LinearLinkedBase._getReverseIterator
- Defined in linked-list/doubly-linked-list.ts:1208

`Protected`_isPredicate

_isPredicate(elementNodeOrPredicate): elementNodeOrPredicate is ((node: DoublyLinkedListNode<E>) => boolean)
The function _isPredicate checks if the input is a function that takes a DoublyLinkedListNode as an argument and returns a boolean.
Parameters
- elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)
  elementNodeOrPredicate - The elementNodeOrPredicate parameter can be one of the following types:
Returns elementNodeOrPredicate is ((node: DoublyLinkedListNode<E>) => boolean)
The _isPredicate method is returning a boolean value indicating whether the elementNodeOrPredicate parameter is a function or not. If the elementNodeOrPredicate is a function, the method will return true, indicating that it is a predicate function.
- Defined in linked-list/doubly-linked-list.ts:1248

[iterator]

[iterator](...args): IterableIterator<E, any, any>
Time Complexity: O(n) Space Complexity: O(1)

The function is an implementation of the Symbol.iterator method that returns an IterableIterator.
Parameters
- Rest...args: any[]
  The args parameter in the code snippet represents a rest parameter. It allows the function to accept any number of arguments as an array. In this case, the args parameter is used to pass any number of arguments to the _getIterator method.
Returns IterableIterator<E, any, any>
Inherited from LinearLinkedBase.[iterator]
- Defined in base/iterable-element-base.ts:32

addAfter

addAfter(existingElementOrNode, newElementOrNode): boolean
Time Complexity: O(1) or O(n) Space Complexity: O(1)

The addAfter function in TypeScript adds a new element or node after an existing element or node in a doubly linked list.
Parameters
- existingElementOrNode: E | DoublyLinkedListNode<E>
  existingElementOrNode represents the element or node in the doubly linked list after which you want to add a new element or node.
- newElementOrNode: E | DoublyLinkedListNode<E>
  The newElementOrNode parameter in the addAfter method represents the element or node that you want to add after the existing element or node in a doubly linked list. This parameter can be either an element value or a DoublyLinkedListNode object that you want to insert
Returns boolean
The addAfter method returns a boolean value - true if the new element or node was successfully added after the existing element or node, and false if the existing element or node was not found in the linked list.
Overrides LinearLinkedBase.addAfter
- Defined in linked-list/doubly-linked-list.ts:889

addAt

addAt(index, newElementOrNode): boolean
Time Complexity: O(n) Space Complexity: O(1)

The addAt function inserts a new element or node at a specified index in a doubly linked list.
Parameters
- index: number
  The index parameter in the addAt method represents the position at which you want to add a new element or node in the doubly linked list. It indicates the location where the new element or node should be inserted.
- newElementOrNode: E | DoublyLinkedListNode<E>
  The newElementOrNode parameter in the addAt method can be either a value of type E or a DoublyLinkedListNode<E> object.
Returns boolean
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 length of the list).
Overrides LinearLinkedBase.addAt
- Defined in linked-list/doubly-linked-list.ts:810

addBefore

addBefore(existingElementOrNode, newElementOrNode): boolean
Time Complexity: O(1) or O(n) Space Complexity: O(1)

The addBefore function in TypeScript adds a new element or node before an existing element or node in a doubly linked list.
Parameters
- existingElementOrNode: E | DoublyLinkedListNode<E>
  The existingElementOrNode parameter in the addBefore method can be either an element of type E or a DoublyLinkedListNode<E>.
- newElementOrNode: E | DoublyLinkedListNode<E>
  The newElementOrNode parameter represents the element or node that you want to add before the existingElementOrNode in a doubly linked list.
Returns boolean
The addBefore method returns a boolean value - true if the new element or node was successfully added before the existing element or node, and false if the existing element or node was not found.
Overrides LinearLinkedBase.addBefore
- Defined in linked-list/doubly-linked-list.ts:847

at

at(index): undefined | E
Time Complexity: O(n) Space Complexity: O(1)

The at function returns the value at a specified index in a linked list, or undefined if the index is out of bounds.
Parameters
- index: number
  The index parameter is a number that represents the position of the element we want to retrieve from the list.
Returns undefined | E
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.
Overrides LinearLinkedBase.at
- Defined in linked-list/doubly-linked-list.ts:731

clear

clear(): void
Time Complexity: O(1) Space Complexity: O(1)

The clear function resets the linked list by setting the head, tail, and length to undefined and 0 respectively.

Returns void
Overrides LinearLinkedBase.clear
- Defined in linked-list/doubly-linked-list.ts:1017

clone

clone(): this
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 this
The clone() method is returning a new instance of the DoublyLinkedList class, which is a copy of the original list.
Overrides LinearLinkedBase.clone
- Defined in linked-list/doubly-linked-list.ts:1098

concat

concat(...items): this
Parameters
- Rest...items: LinearBase<E, R, LinkedListNode<E>>[]
  The concat method you provided takes in a variable number of arguments of type E or LinearBase<E, R>. The method concatenates these items to the current list and returns a new list with the concatenated items.
Returns this
The concat method is returning a new instance of the class that it belongs to, with the items passed as arguments concatenated to it.
Inherited from LinearLinkedBase.concat
- Defined in base/linear-base.ts:479

countOccurrences

countOccurrences(elementOrNode): number
Time Complexity: O(n) Space Complexity: O(1)

The function countOccurrences iterates through a doubly linked list and counts the occurrences of a specified element or nodes that satisfy a given predicate.
Parameters
- elementOrNode: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)
  The elementOrNode parameter in the countOccurrences method can accept three types of values:
Returns number
The countOccurrences method returns the number of occurrences of the specified element, node, or predicate function in the doubly linked list.
- Defined in linked-list/doubly-linked-list.ts:1177

delete

delete(elementOrNode): boolean
Time Complexity: O(1) or O(n) Space Complexity: O(1)

The delete function removes a specified element or node from a doubly linked list if it exists.
Parameters
- elementOrNode: undefined | E | DoublyLinkedListNode<E>
  The elementOrNode parameter in the delete method can accept an element of type E, a DoublyLinkedListNode of type E, or it can be undefined. This parameter is used to identify the node that needs to be deleted from the doubly linked list
Returns boolean
The delete method returns a boolean value - true if the element or node was successfully deleted from the doubly linked list, and false if the element or node was not found in the list.
Overrides LinearLinkedBase.delete
- Defined in linked-list/doubly-linked-list.ts:980

deleteAt

deleteAt(index): undefined | E
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.
Parameters
- index: number
  The index parameter represents the position of the element that needs to be deleted in the data structure. It is of type number.
Returns undefined | E
The method deleteAt returns the value of the node that was deleted, or undefined if the index is out of bounds.
Overrides LinearLinkedBase.deleteAt
- Defined in linked-list/doubly-linked-list.ts:944

every

every(predicate, thisArg?): boolean
Time Complexity: O(n) Space Complexity: O(1)

The every function checks if every element in the array satisfies a given predicate.
Parameters
- predicate: ElementCallback<E, R, boolean>
  The predicate parameter is a callback function that takes three arguments: the current element being processed, its index, and the array it belongs to. It should return a boolean value indicating whether the element satisfies a certain condition or not.
- OptionalthisArg: any
  The thisArg parameter is an optional argument that specifies the value to be used as this when executing the predicate function. If thisArg is provided, it will be passed as the this value to the predicate function. If thisArg is
Returns boolean
The every method is returning a boolean value. It returns true if every element in the array satisfies the provided predicate function, and false otherwise.
Inherited from LinearLinkedBase.every
- Defined in base/iterable-element-base.ts:62

fill

fill(value, start?, end?): this
Time Complexity: O(n) Space Complexity: O(1)

The fill function in TypeScript fills a specified range in an array-like object with a given value.
Parameters
- value: E
  The value parameter in the fill method represents the element that will be used to fill the specified range in the array.
- Optionalstart: number = 0
  The start parameter specifies the index at which to start filling the array with the specified value. If not provided, it defaults to 0, indicating the beginning of the array.
- end: number = ...
  The end parameter in the fill function represents the index at which the filling of values should stop. It specifies the end of the range within the array where the value should be filled.
Returns this
The fill method is returning the modified object (this) after filling the specified range with the provided value.
Inherited from LinearLinkedBase.fill
- Defined in base/linear-base.ts:343

filter

filter(callback, thisArg?): DoublyLinkedList<E, R>
Time Complexity: O(n) Space Complexity: O(n)

The filter function creates a new DoublyLinkedList by iterating over the elements of the current list and applying a callback function to each element, returning only the elements for which the callback function returns true.
Parameters
- callback: ElementCallback<E, R, boolean>
  The callback parameter is a function that will be called for each element in the DoublyLinkedList. It takes three arguments: the current element, the index of the current element, and the DoublyLinkedList itself. The callback function should return a boolean value indicating whether the current element should be included
- OptionalthisArg: any
  The thisArg parameter is an optional argument that specifies the value to be used as this when executing the callback function. If thisArg is provided, it will be passed as the this value to the callback function. If thisArg is
Returns DoublyLinkedList<E, R>
The filter method is returning a new DoublyLinkedList object that contains the elements that pass the filter condition specified by the callback function.
Overrides LinearLinkedBase.filter
- Defined in linked-list/doubly-linked-list.ts:1119

find

find<S>(predicate, thisArg?): undefined | S
Type Parameters
- S
Parameters
- predicate: ElementCallback<E, R, S>
- OptionalthisArg: any
Returns undefined | S
Inherited from LinearLinkedBase.find
- Defined in base/iterable-element-base.ts:116
find(predicate, thisArg?): undefined | E
Parameters
- predicate: ElementCallback<E, R, unknown>
- OptionalthisArg: any
Returns undefined | E
Inherited from LinearLinkedBase.find
- Defined in base/iterable-element-base.ts:117

findIndex

findIndex(predicate, thisArg?): number
Time Complexity: O(n) Space Complexity: O(1)

The findIndex function iterates over an array and returns the index of the first element that satisfies the provided predicate function.
Parameters
- predicate: ElementCallback<E, R, boolean>
  The predicate parameter in the findIndex function is a callback function that takes three arguments: item, index, and the array this. It should return a boolean value indicating whether the current element satisfies the condition being checked for.
- OptionalthisArg: any
  The thisArg parameter in the findIndex function is an optional parameter that specifies the value to use as this when executing the predicate function. If provided, the predicate function will be called with thisArg as its this value. If @returns ThefindIndex` method is returning the index of the first element in the array that satisfies the provided predicate function. If no such element is found, it returns -1.
Returns number
Inherited from LinearLinkedBase.findIndex
- Defined in base/linear-base.ts:136

forEach

forEach(callbackfn, thisArg?): void
Time Complexity: O(n) Space Complexity: O(1)

The forEach function iterates over each element in an array-like object and calls a callback function for each element.
Parameters
- callbackfn: ElementCallback<E, R, void>
  The callbackfn parameter is a function that will be called for each element in the array. It takes three arguments: the current element being processed, the index of the current element, and the array that forEach was called upon.
- OptionalthisArg: any
  The thisArg parameter is an optional argument that specifies the value to be used as this when executing the callbackfn function. If thisArg is provided, it will be passed as the this value to the callbackfn function. If `thisArg
Returns void
Inherited from LinearLinkedBase.forEach
- Defined in base/iterable-element-base.ts:109

getBackward

getBackward(elementNodeOrPredicate): undefined | E
Time Complexity: O(n) Space Complexity: O(1)

The getBackward function searches for a specific element in a doubly linked list starting from the tail and moving backwards.
Parameters
- elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)
  elementNodeOrPredicate - The elementNodeOrPredicate parameter in the getBackward function can be one of the following types:
Returns undefined | E
The getBackward method returns the value of the element node that matches the provided predicate when traversing the doubly linked list backwards. If no matching element is found, it returns undefined.
- Defined in linked-list/doubly-linked-list.ts:1060

getNode

getNode(elementNodeOrPredicate): undefined | DoublyLinkedListNode<E>
Time Complexity: O(n) Space Complexity: O(1)

This TypeScript function searches for a node in a doubly linked list based on a given element node or predicate.
Parameters
- elementNodeOrPredicate:
      | undefined
      | E
      | DoublyLinkedListNode<E>
      | ((node: DoublyLinkedListNode<E>) => boolean)
  The getNode method you provided is used to find a node in a doubly linked list based on a given element, node, or predicate function. The elementNodeOrPredicate parameter can be one of the following:
Returns undefined | DoublyLinkedListNode<E>
The getNode method returns a DoublyLinkedListNode<E> or undefined based on the input elementNodeOrPredicate. If the input is undefined, the method returns undefined. Otherwise, it iterates through the linked list starting from the head node and applies the provided predicate function to each node. If a node satisfies the predicate, that node is returned. If
- Defined in linked-list/doubly-linked-list.ts:778

getNodeAt

getNodeAt(index): undefined | DoublyLinkedListNode<E>
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 range.
Parameters
- index: number
  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 undefined | DoublyLinkedListNode<E>
The method getNodeAt(index: number) returns a DoublyLinkedListNode<E> object if the index is within the valid range of the linked list, otherwise it returns undefined.
Overrides LinearLinkedBase.getNodeAt
- Defined in linked-list/doubly-linked-list.ts:751

has

has(element): boolean
Time Complexity: O(n) Space Complexity: O(1)

The function checks if a given element exists in a collection.
Parameters
- element: E
  The parameter "element" is of type E, which means it can be any type. It represents the element that we want to check for existence in the collection.
Returns boolean
a boolean value. It returns true if the element is found in the collection, and false otherwise.
Inherited from LinearLinkedBase.has
- Defined in base/iterable-element-base.ts:154

indexOf

indexOf(searchElement, fromIndex?): number
Time Complexity: O(n) Space Complexity: O(1)

The function overrides the indexOf method to improve performance by searching for an element in a custom array implementation starting from a specified index.
Parameters
- searchElement: E
  The searchElement parameter is the element that you are searching for within the array. The indexOf method will return the index of the first occurrence of this element within the array.
- OptionalfromIndex: number = 0
  The fromIndex parameter in the indexOf method specifies the index in the array at which to start the search for the searchElement. If provided, the search will begin at the specified index and continue to the end of the array. If not provided, the search will start at index
Returns number
The indexOf method is returning the index of the searchElement if it is found in the array starting from the fromIndex. If the searchElement is not found, it returns -1.
Inherited from LinearLinkedBase.indexOf
- Defined in base/linear-base.ts:420

isEmpty

isEmpty(): boolean
Time Complexity: O(1) Space Complexity: O(1)

The function checks if a variable has a length greater than zero and returns a boolean value.

Returns boolean
A boolean value is being returned.
Overrides LinearLinkedBase.isEmpty
- Defined in linked-list/doubly-linked-list.ts:1007

isNode

isNode(elementNodeOrPredicate): elementNodeOrPredicate is DoublyLinkedListNode<E>
Time Complexity: O(1) Space Complexity: O(1)

The function isNode in TypeScript checks if a given input is an instance of DoublyLinkedListNode.
Parameters
- elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)
  elementNodeOrPredicate - The elementNodeOrPredicate parameter in the isNode function can be one of the following types:
Returns elementNodeOrPredicate is DoublyLinkedListNode<E>
The isNode function is checking if the elementNodeOrPredicate parameter is an instance of DoublyLinkedListNode<E>. If it is, the function returns true, indicating that the parameter is a DoublyLinkedListNode<E>. If it is not an instance of DoublyLinkedListNode<E>, the function returns false.
- Defined in linked-list/doubly-linked-list.ts:573

join

join(separator?): string
Time Complexity: O(n) Space Complexity: O(1)

The join function in TypeScript returns a string by joining the elements of an array with a specified separator.
Parameters
- Optionalseparator: string = ','
  The separator parameter is a string that specifies the character or characters that will be used to separate each element when joining them into a single string. By default, the separator is set to a comma (,), but you can provide a different separator if needed.
Returns string
The join method is being returned, which takes an optional separator parameter (defaulting to a comma) and returns a string created by joining all elements of the array after converting it to an array.
Inherited from LinearLinkedBase.join
- Defined in base/linear-base.ts:249

lastIndexOf

lastIndexOf(searchElement, fromIndex?): number
Time Complexity: O(n) Space Complexity: O(1)

The function overrides the lastIndexOf method in TypeScript to improve performance by searching for an element in reverse order starting from a specified index.
Parameters
- searchElement: E
  The searchElement parameter is the element that you want to find within the array. The lastIndexOf method searches the array for this element starting from the end of the array (or from the specified fromIndex if provided) and returns the index of the last occurrence of the element
- fromIndex: number = ...
  The fromIndex parameter in the lastIndexOf method specifies the index at which to start searching for the searchElement in the array. If provided, the search will begin at this index and move towards the beginning of the array. If not provided, the search will start at the
Returns number
The lastIndexOf method is being overridden to search for the searchElement starting from the specified fromIndex (defaulting to the end of the array). It iterates over the array in reverse order using a custom iterator _getReverseIterator and returns the index of the last occurrence of the searchElement if found, or -1 if not found.
Inherited from LinearLinkedBase.lastIndexOf
- Defined in base/linear-base.ts:459

map

map<EM, RM>(callback, toElementFn?, thisArg?): DoublyLinkedList<EM, RM>
Time Complexity: O(n) Space Complexity: O(n)

The map function takes a callback function and returns a new DoublyLinkedList with the results of applying the callback to each element in the original list.
Type Parameters
- EM
- RM
Parameters
- callback: ElementCallback<E, R, EM>
  The callback parameter is a function that will be called for each element in the original DoublyLinkedList. It takes three arguments: current (the current element being processed), index (the index of the current element), and this (the original DoublyLinkedList). The callback function should return a value of type
- OptionaltoElementFn: ((rawElement: RM) => EM)
  The toElementFn parameter is an optional function that can be used to convert the raw element (RR) to the desired element type (T). It takes the raw element as input and returns the converted element. If this parameter is not provided, the raw element will be used as is.
  - - (rawElement): EM
    - Parameters
      rawElement: RM
      Returns EM
- OptionalthisArg: any
  The thisArg parameter is an optional argument that allows you to specify the value of this within the callback function. It is used to set the context or scope in which the callback function will be executed. If thisArg is provided, it will be used as the value of
Returns DoublyLinkedList<EM, RM>
a new instance of the DoublyLinkedList class with elements of type T and RR.
Overrides LinearLinkedBase.map
- Defined in linked-list/doubly-linked-list.ts:1151

pop

pop(): undefined | E
Time Complexity: O(1) Space Complexity: O(1)

The pop() function removes and returns the value of the last element in a linked list.

Returns undefined | E
The method is returning the value of the removed node.
- Defined in linked-list/doubly-linked-list.ts:610

print

print(): void
Time Complexity: O(n) Space Complexity: O(n)

The print function logs the elements of an array to the console.

Returns void
Inherited from LinearLinkedBase.print
- Defined in base/iterable-element-base.ts:214

push

push(elementOrNode): boolean
Time Complexity: O(1) Space Complexity: O(1)

The push function adds a new element or node to the end of a doubly linked list.
Parameters
- elementOrNode: E | DoublyLinkedListNode<E>
  The elementOrNode parameter in the push method can accept either an element of type E or a DoublyLinkedListNode<E> object.
Returns boolean
The push method is returning a boolean value, specifically true.
Overrides LinearLinkedBase.push
- Defined in linked-list/doubly-linked-list.ts:588

pushMany

pushMany(elements): boolean[]
Time Complexity: O(k) Space Complexity: O(k)

The function pushMany iterates over elements and pushes them into a data structure, applying a transformation function if provided.
Parameters
- elements: Iterable<E, any, any> | Iterable<R, any, any> | Iterable<DoublyLinkedListNode<E>, any, any>
  The elements parameter in the pushMany function can accept an iterable containing elements of type E, R, or DoublyLinkedListNode<E>. The function iterates over each element in the iterable and pushes it onto the linked list. If a transformation function to @returns The pushMany function is returning an array of boolean values (ans`) which indicate the success or failure of pushing each element into the data structure.
Returns boolean[]
Overrides LinearLinkedBase.pushMany
- Defined in linked-list/doubly-linked-list.ts:683

reduce

reduce(callbackfn): E
Parameters
- callbackfn: ReduceElementCallback<E, R>
Returns E
Inherited from LinearLinkedBase.reduce
- Defined in base/iterable-element-base.ts:161
reduce(callbackfn, initialValue): E
Parameters
- callbackfn: ReduceElementCallback<E, R>
- initialValue: E
Returns E
Inherited from LinearLinkedBase.reduce
- Defined in base/iterable-element-base.ts:162
reduce<U>(callbackfn, initialValue): U
Type Parameters
- U
Parameters
- callbackfn: ReduceElementCallback<E, R, U>
- initialValue: U
Returns U
Inherited from LinearLinkedBase.reduce
- Defined in base/iterable-element-base.ts:163

reduceRight

reduceRight(callbackfn): E
Parameters
- callbackfn: ReduceLinearCallback<E>
Returns E
Inherited from LinearLinkedBase.reduceRight
- Defined in base/linear-base.ts:606
reduceRight(callbackfn, initialValue): E
Parameters
- callbackfn: ReduceLinearCallback<E>
- initialValue: E
Returns E
Inherited from LinearLinkedBase.reduceRight
- Defined in base/linear-base.ts:608
reduceRight<U>(callbackfn, initialValue): U
Type Parameters
- U
Parameters
- callbackfn: ReduceLinearCallback<E, U>
- initialValue: U
Returns U
Inherited from LinearLinkedBase.reduceRight
- Defined in base/linear-base.ts:610

reverse

reverse(): this
Time Complexity: O(n) Space Complexity: O(1)

The reverse function reverses the order of the elements in a doubly linked list.

Returns this
Overrides LinearLinkedBase.reverse
- Defined in linked-list/doubly-linked-list.ts:1078

search

search(elementNodeOrPredicate): undefined | E
Time Complexity: O(n) Space Complexity: O(1)

This function retrieves an element from a doubly linked list based on a given element node or predicate.
Parameters
- elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)
  elementNodeOrPredicate - The get method takes in a parameter called elementNodeOrPredicate, which can be one of the following types:
Returns undefined | E
The get method returns the value of the first node in the doubly linked list that satisfies the provided predicate function. If no such node is found, it returns undefined.
- Defined in linked-list/doubly-linked-list.ts:1035

setAt

setAt(index, value): 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.
Parameters
- index: number
  The index parameter in the setAt method refers to the position in the data structure where you want to set a new value.
- value: E
  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 boolean
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.
Overrides LinearLinkedBase.setAt
- Defined in linked-list/doubly-linked-list.ts:925

shift

shift(): undefined | E
Time Complexity: O(1) Space Complexity: O(1)

The shift() function removes and returns the value of the first element in a doubly linked list.

Returns undefined | E
The value of the removed node.
- Defined in linked-list/doubly-linked-list.ts:631

slice

slice(start?, end?): this
Time Complexity: O(m) Space Complexity: O(m)

The slice method is overridden to improve performance by creating a new instance and iterating through the array to extract a subset based on the specified start and end indices.
Parameters
- Optionalstart: number = 0
  The start parameter in the slice method specifies the index at which to begin extracting elements from the array. If no start parameter is provided, the default value is 0, indicating that extraction should start from the beginning of the array.
- end: number = ...
  The end parameter in the slice method represents the index at which to end the slicing of the array. If not provided, it defaults to the length of the array.
Returns this
The slice method is returning a new instance of the array implementation with elements sliced from the original array based on the start and end parameters.
Inherited from LinearLinkedBase.slice
- Defined in base/linear-base.ts:521

some

some(predicate, thisArg?): boolean
Time Complexity: O(n) Space Complexity: O(1)

The "some" function checks if at least one element in a collection satisfies a given predicate.
Parameters
- predicate: ElementCallback<E, R, boolean>
  The predicate parameter is a callback function that takes three arguments: value, index, and array. It should return a boolean value indicating whether the current element satisfies the condition.
- OptionalthisArg: any
  The thisArg parameter is an optional argument that specifies the value to be used as the this value when executing the predicate function. If thisArg is provided, it will be passed as the this value to the predicate function. If `thisArg
Returns boolean
a boolean value. It returns true if the predicate function returns true for any element in the collection, and false otherwise.
Inherited from LinearLinkedBase.some
- Defined in base/iterable-element-base.ts:86

sort

sort(compareFn?): this
Time Complexity: O(n log n) Space Complexity: O(n)

The sort function in TypeScript sorts the elements of a collection using a specified comparison function.
Parameters
- OptionalcompareFn: ((a: E, b: E) => number)
  The compareFn parameter is a function that defines the sort order. It takes two elements a and b as input and returns a number indicating their relative order. If the returned value is negative, a comes before b. If the returned value is positive, @returns Thesort` method is returning the instance of the object on which it is called (this), after sorting the elements based on the provided comparison function (compareFn).
  - - (a, b): number
    - Parameters
      a: E
      b: E
      Returns number
Returns this
Inherited from LinearLinkedBase.sort
- Defined in base/linear-base.ts:183

splice

splice(start, deleteCount?, ...items): this
Time Complexity: O(n + m) Space Complexity: O(m)

The function overrides the splice method to handle deletion and insertion of elements in a data structure while returning the removed elements.
Parameters
- start: number
  The start parameter in the splice method indicates the index at which to start modifying the array.
- OptionaldeleteCount: number = 0
  The deleteCount parameter in the splice method specifies the number of elements to remove from the array starting at the specified start index. If deleteCount is not provided, it defaults to 0, meaning no elements will be removed but new elements can still be inserted at
- Rest...items: E[]
  The items parameter in the splice method represents the elements that will be inserted into the array at the specified start index. These elements can be of any type and there can be multiple elements passed as arguments to be inserted into the array.
Returns this
The splice method is returning a new instance of the data structure that was modified by removing elements specified by the start and deleteCount parameters, and inserting new elements provided in the items array.
Inherited from LinearLinkedBase.splice
- Defined in base/linear-base.ts:561

toArray

toArray(): E[]
Time Complexity: O(n) Space Complexity: O(n)

The toArray function converts a linked list into an array.

Returns E[]
The toArray() method is returning an array of type E[].
Inherited from LinearLinkedBase.toArray
- Defined in base/iterable-element-base.ts:194

toReversedArray

toReversedArray(): E[]
Time Complexity: O(n) Space Complexity: O(n)

The function toReversedArray takes an array and returns a new array with its elements in reverse order.

Returns E[]
The toReversedArray() function returns an array of elements of type E in reverse order.
Inherited from LinearLinkedBase.toReversedArray
- Defined in base/linear-base.ts:262

toVisual

toVisual(): E[]
Time Complexity: O(n) Space Complexity: O(n)

The print function logs the elements of an array to the console.

Returns E[]
Inherited from LinearLinkedBase.toVisual
- Defined in base/iterable-element-base.ts:204

unshift

unshift(elementOrNode): boolean
Time Complexity: O(1) Space Complexity: O(1)

The unshift function adds a new element or node to the beginning of a doubly linked list.
Parameters
- elementOrNode: E | DoublyLinkedListNode<E>
  The elementOrNode parameter in the unshift method can be either an element of type E or a DoublyLinkedListNode containing an element of type E.
Returns boolean
The unshift method is returning a boolean value, specifically true.
- Defined in linked-list/doubly-linked-list.ts:655

unshiftMany

unshiftMany(elements): boolean[]
Time Complexity: O(k) Space Complexity: O(k)

The function unshiftMany iterates through a collection of elements and adds them to the beginning of a Doubly Linked List, returning an array of boolean values indicating the success of each insertion.
Parameters
- elements: Iterable<E, any, any> | Iterable<R, any, any> | Iterable<DoublyLinkedListNode<E>, any, any>
  The elements parameter in the unshiftMany function can accept an iterable containing elements of type E, R, or DoublyLinkedListNode<E>. The function iterates over each element in the iterable and performs an unshift operation on the doubly linked list
Returns boolean[]
The unshiftMany function returns an array of boolean values indicating the success of each unshift operation performed on the elements passed as input.
- Defined in linked-list/doubly-linked-list.ts:709

values

values(): IterableIterator<E, any, any>
Time Complexity: O(n) Space Complexity: O(n)

The function returns an iterator that yields all the values in the object.

Returns IterableIterator<E, any, any>
Inherited from LinearLinkedBase.values
- Defined in base/iterable-element-base.ts:42

`Static`fromArray

fromArray<E>(data): DoublyLinkedList<E, any>
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 given array.
Type Parameters
- E
Parameters
- data: E[]
  The data parameter is an array of elements of type E.
Returns DoublyLinkedList<E, any>
The fromArray function returns a DoublyLinkedList object.
- Defined in linked-list/doubly-linked-list.ts:555

Class DoublyLinkedList<E, R>

Example

Example

Example

Example

Example

Example

Type Parameters

Hierarchy

Index

Constructors

Accessors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns DoublyLinkedList<E, R>

Accessors

first

Returns undefined | E

last

Returns undefined | E

Methods

Protected_createInstance

Parameters

Returns this

Protected_ensureNode

Parameters

Returns DoublyLinkedListNode<E>

Protected_ensurePredicate

Parameters

Returns ((node: DoublyLinkedListNode<E>) => boolean)

Parameters

Returns boolean

Protected_getIterator

Returns IterableIterator<E, any, any>

Protected_getNodeIterator

Returns IterableIterator<DoublyLinkedListNode<E>, any, any>

Protected_getPrevNode

Parameters

Returns undefined | DoublyLinkedListNode<E>

Protected_getReverseIterator

Returns IterableIterator<E, any, any>

Protected_isPredicate

Parameters

Returns elementNodeOrPredicate is ((node: DoublyLinkedListNode<E>) => boolean)

[iterator]

Parameters

Returns IterableIterator<E, any, any>

addAfter

Parameters

Returns boolean

addAt

Parameters

Returns boolean

addBefore

Parameters

Returns boolean

at

Parameters

Returns undefined | E

clear

Returns void

clone

Returns this

concat

Parameters

Returns this

countOccurrences

Parameters

Returns number

delete

Parameters

Returns boolean

deleteAt

Parameters

Returns undefined | E

every

Parameters

`Protected`_createInstance

`Protected`_ensureNode

`Protected`_ensurePredicate

`Protected`_getIterator

`Protected`_getNodeIterator

`Protected`_getPrevNode

`Protected`_getReverseIterator

`Protected`_isPredicate