Class DoublyLinkedList<E, R>

  1. Node Structure: Each node contains three parts: a data field, a pointer (or reference) to the previous node, and a pointer to the next node. This structure allows traversal of the linked list in both directions.
  2. Bidirectional Traversal: Unlike singly linked lists, doubly linked lists can be easily traversed forwards or backwards. This makes insertions and deletions in the list more flexible and efficient.
  3. No Centralized Index: Unlike arrays, elements in a linked list are not stored contiguously, so there is no centralized index. Accessing elements in a linked list typically requires traversing from the head or tail node.
  4. High Efficiency in Insertion and Deletion: Adding or removing elements in a linked list does not require moving other elements, making these operations more efficient than in arrays.

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.size * 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.size >= 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 size
      get size(): number {
        return this.list.size;
      }

      // 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.size); // 1

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

    console.log(cache.size); // 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 (view full)

Accessors

first head last size tail toElementFn

Methods

_ensureNode _ensurePredicate _getIterator _isPredicate [iterator] addAfter addAt addBefore at clear clone countOccurrences delete deleteAt every filter find forEach get getBackward getNode getNodeAt has indexOf isEmpty isNode map pop print push reduce reverse shift some toArray toReversedArray toVisual unshift values fromArray

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.

head

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.

size

  • get size(): number

  • The function returns the size of an object.

    Returns number

    The size of the object, which is a number.

tail

toElementFn

  • get toElementFn(): undefined | ((rawElement: R) => E)

  • The function returns the _toElementFn property, which is a function that converts a raw element to a specific type.

    Returns undefined | ((rawElement: R) => E)

    The function get toElementFn() is returning either a function that takes a raw element rawElement of type R and returns an element E, or undefined if no function is assigned to _toElementFn.

Methods

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.

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

    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.

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>

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

    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.

[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>

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.

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 size of the list).

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.

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.

clear

  • clear(): void

  • Time Complexity: O(1) Space Complexity: O(1)

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

    Returns void

clone

  • clone(): DoublyLinkedList<E, R>

  • 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 DoublyLinkedList<E, R>

    The clone() method is returning a new instance of the DoublyLinkedList class, which is a copy of the original list.

countOccurrences

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.

deleteAt

  • deleteAt(index): boolean

  • 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 boolean

    The method deleteAt returns the value of the node that was deleted, or undefined if the index is out of bounds.

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, DoublyLinkedList<E, R>>

      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.

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, DoublyLinkedList<E, R>>

      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.

find

  • find(callbackfn, thisArg?): undefined | E

  • Time Complexity: O(n) Space Complexity: O(1)

    The find function iterates over the elements of an array-like object and returns the first element that satisfies the provided callback function.

    Parameters

    • callbackfn: ElementCallback<E, R, boolean, DoublyLinkedList<E, R>>

      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 itself. The function should return a boolean value indicating whether the current element matches the desired condition.

    • 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 The findmethod returns the first element in the array that satisfies the provided callback function. If no element satisfies the callback function,undefined` is returned.

    Returns undefined | E

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, DoublyLinkedList<E, R>>

      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

get

  • get(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.

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.

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

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.

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.

indexOf

  • indexOf(elementNodeOrPredicate): number

  • Time Complexity: O(n) Space Complexity: O(1)

    This function finds the index of a specified element, node, or predicate in a doubly linked list.

    Parameters

    • elementNodeOrPredicate: E | DoublyLinkedListNode<E> | ((node: DoublyLinkedListNode<E>) => boolean)

      elementNodeOrPredicate - The indexOf method takes in a parameter elementNodeOrPredicate, which can be one of the following:

    Returns number

    The indexOf method returns the index of the element in the doubly linked list that matches the provided element, node, or predicate. If no match is found, it returns -1.

isEmpty

  • isEmpty(): boolean

  • Time Complexity: O(1) Space Complexity: O(1)

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

    Returns boolean

    A boolean value is being returned.

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.

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, DoublyLinkedList<E, R>>

      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.

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.

print

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.

reduce

  • reduce<U>(callbackfn, initialValue): U

  • Time Complexity: O(n) Space Complexity: O(1)

    The reduce function iterates over the elements of an array-like object and applies a callback function to reduce them into a single value.

    Type Parameters

    • U

    Parameters

    • callbackfn: ReduceElementCallback<E, R, U, DoublyLinkedList<E, R>>

      The callbackfn parameter is a function that will be called for each element in the array. It takes four arguments:

    • initialValue: U

      The initialValue parameter is the initial value of the accumulator. It is the value that the accumulator starts with before the reduction operation begins.

    Returns U

    The reduce method is returning the final value of the accumulator after iterating over all the elements in the array and applying the callback function to each element.

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

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.

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, DoublyLinkedList<E, R>>

      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.

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[].

toReversedArray

  • toReversedArray(): E[]

  • Time Complexity: O(n) Space Complexity: O(n)

    The toReversedArray function converts a doubly linked list into an array in reverse order.

    Returns E[]

    The toReversedArray() function returns an array of type E[].

toVisual

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.

values

StaticfromArray

  • 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.

Settings

Member Visibility

On This Page

Accessors
Methods