Doubly Linked List - Problem

Implement a doubly linked list with bidirectional traversal, insertion, and deletion operations at any position.

Your doubly linked list should support the following operations:

insertAtHead(val) - Insert a new node with given value at the beginning
insertAtTail(val) - Insert a new node with given value at the end
insertAtIndex(index, val) - Insert a new node at the specified index
deleteAtIndex(index) - Delete the node at the specified index
get(index) - Get the value of the node at the specified index
toArray() - Return all values as an array for testing

The doubly linked list should maintain both forward and backward pointers, allowing efficient bidirectional traversal.

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["insertAtHead", 1], ["insertAtTail", 2], ["insertAtIndex", 1, 3], ["get", 0], ["toArray"]]

› Output: [null, null, null, 1, [1, 3, 2]]

💡 Note: insertAtHead(1) → list: [1], insertAtTail(2) → list: [1,2], insertAtIndex(1,3) → list: [1,3,2], get(0) returns 1, toArray() returns [1,3,2]

Example 2 — Delete Operations

$ Input: operations = [["insertAtHead", 5], ["insertAtTail", 10], ["deleteAtIndex", 0], ["toArray"]]

› Output: [null, null, null, [10]]

💡 Note: insertAtHead(5) → list: [5], insertAtTail(10) → list: [5,10], deleteAtIndex(0) removes first element → list: [10], toArray() returns [10]

Example 3 — Invalid Index

$ Input: operations = [["insertAtHead", 7], ["get", 5], ["deleteAtIndex", 10], ["toArray"]]

› Output: [null, -1, null, [7]]

💡 Note: insertAtHead(7) → list: [7], get(5) returns -1 (invalid index), deleteAtIndex(10) does nothing (invalid index), toArray() returns [7]

Constraints

1 ≤ operations.length ≤ 1000
-1000 ≤ val ≤ 1000
0 ≤ index ≤ size
get() returns -1 for invalid indices

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 29 f Facebook 25

The key insight is using both next and prev pointers to enable bidirectional traversal, reducing average access time. The optimal approach chooses the shorter path (head or tail) based on target index position. Time: O(n/2) average, Space: O(1).

Common Approaches

✓ Bidirectional Traversal Optimization

⏱️ Time: O(n/2) Space: O(1)

Optimize traversal by maintaining both head and tail pointers, then choosing to traverse from whichever end is closer to the target index. For positions in the first half, traverse from head; for positions in the second half, traverse from tail backwards.

Single Direction Traversal

⏱️ Time: O(n) Space: O(1)

Implement doubly linked list operations by always starting from the head and traversing forward to reach the desired position. Each node maintains both next and prev pointers, but we only use forward traversal.

Bidirectional Traversal Optimization — Algorithm Steps

Determine if target index is closer to head or tail
If index < size/2, traverse forward from head
If index >= size/2, traverse backward from tail
Perform operation with optimal approach

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Distance

Compare index to size/2 to determine shorter path

Choose Direction

Start from head if closer, tail if farther

Traverse Optimally

Walk the shortest path to target position

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct DoublyListNode {
    int val;
    struct DoublyListNode* next;
    struct DoublyListNode* prev;
} DoublyListNode;

typedef struct {
    DoublyListNode* head;
    DoublyListNode* tail;
    int size;
} DoublyLinkedList;

DoublyLinkedList* createDoublyLinkedList() {
    DoublyLinkedList* dll = (DoublyLinkedList*)malloc(sizeof(DoublyLinkedList));
    dll->head = NULL;
    dll->tail = NULL;
    dll->size = 0;
    return dll;
}

void insertAtHead(DoublyLinkedList* dll, int val) {
    DoublyListNode* newNode = (DoublyListNode*)malloc(sizeof(DoublyListNode));
    newNode->val = val;
    newNode->next = NULL;
    newNode->prev = NULL;
    
    if (!dll->head) {
        dll->head = dll->tail = newNode;
    } else {
        newNode->next = dll->head;
        dll->head->prev = newNode;
        dll->head = newNode;
    }
    dll->size++;
}

void insertAtTail(DoublyLinkedList* dll, int val) {
    DoublyListNode* newNode = (DoublyListNode*)malloc(sizeof(DoublyListNode));
    newNode->val = val;
    newNode->next = NULL;
    newNode->prev = NULL;
    
    if (!dll->tail) {
        dll->head = dll->tail = newNode;
    } else {
        dll->tail->next = newNode;
        newNode->prev = dll->tail;
        dll->tail = newNode;
    }
    dll->size++;
}

void insertAtIndex(DoublyLinkedList* dll, int index, int val) {
    if (index < 0 || index > dll->size) return;
    if (index == 0) {
        insertAtHead(dll, val);
        return;
    }
    if (index == dll->size) {
        insertAtTail(dll, val);
        return;
    }
    
    DoublyListNode* current;
    if (index < dll->size / 2) {
        current = dll->head;
        for (int i = 0; i < index; i++) {
            current = current->next;
        }
    } else {
        current = dll->tail;
        for (int i = 0; i < dll->size - index - 1; i++) {
            current = current->prev;
        }
        current = current->next;
    }
    
    DoublyListNode* newNode = (DoublyListNode*)malloc(sizeof(DoublyListNode));
    newNode->val = val;
    newNode->next = current;
    newNode->prev = current->prev;
    current->prev->next = newNode;
    current->prev = newNode;
    dll->size++;
}

void deleteAtIndex(DoublyLinkedList* dll, int index) {
    if (index < 0 || index >= dll->size) return;
    
    if (dll->size == 1) {
        free(dll->head);
        dll->head = dll->tail = NULL;
        dll->size = 0;
        return;
    }
    
    DoublyListNode* current;
    if (index < dll->size / 2) {
        current = dll->head;
        for (int i = 0; i < index; i++) {
            current = current->next;
        }
    } else {
        current = dll->tail;
        for (int i = 0; i < dll->size - index - 1; i++) {
            current = current->prev;
        }
    }
    
    if (current->prev) {
        current->prev->next = current->next;
    } else {
        dll->head = current->next;
    }
    
    if (current->next) {
        current->next->prev = current->prev;
    } else {
        dll->tail = current->prev;
    }
    
    free(current);
    dll->size--;
}

int get(DoublyLinkedList* dll, int index) {
    if (index < 0 || index >= dll->size) return -1;
    
    DoublyListNode* current;
    if (index < dll->size / 2) {
        current = dll->head;
        for (int i = 0; i < index; i++) {
            current = current->next;
        }
    } else {
        current = dll->tail;
        for (int i = 0; i < dll->size - index - 1; i++) {
            current = current->prev;
        }
    }
    
    return current->val;
}

void printArray(DoublyLinkedList* dll) {
    printf("[");
    DoublyListNode* current = dll->head;
    int first = 1;
    while (current) {
        if (!first) printf(",");
        printf("%d", current->val);
        current = current->next;
        first = 0;
    }
    printf("]");
}

int main() {
    DoublyLinkedList* dll = createDoublyLinkedList();
    
    insertAtHead(dll, 1);
    insertAtTail(dll, 2);
    insertAtIndex(dll, 1, 3);
    
    printf("[null,null,null,");
    printf("%d,", get(dll, 0));
    printArray(dll);
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n/2)

Average case traverses only half the list by choosing optimal direction

✓ Linear Growth

Space Complexity

O(1)

Uses constant extra space for temporary pointers and size tracking

✓ Linear Space

34.5K Views

Medium Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Doubly Linked List - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bidirectional Traversal Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler