Design Linked List - Practice Coding Problems

Design Linked List - Problem

Design your own linked list data structure! Your task is to implement a fully functional linked list with all the essential operations.

You can choose between a singly linked list (each node points to the next) or a doubly linked list (each node has both next and previous pointers). All nodes are 0-indexed.

Your MyLinkedList class must support:
• get(index) - Retrieve value at given index (return -1 if invalid)
• addAtHead(val) - Insert new node at the beginning
• addAtTail(val) - Append new node at the end
• addAtIndex(index, val) - Insert node before given index
• deleteAtIndex(index) - Remove node at given index

This problem tests your understanding of pointer manipulation, memory management, and edge case handling - fundamental skills for any software engineer!

Input & Output

example_1.py — Basic Operations

$ Input: ["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"] [[], [1], [3], [1, 2], [1], [1], [1]]

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

💡 Note: Initialize empty list → Add 1 at head: [1] → Add 3 at tail: [1,3] → Add 2 at index 1: [1,2,3] → Get index 1: returns 2 → Delete index 1: [1,3] → Get index 1: returns 3

example_2.py — Edge Cases

$ Input: ["MyLinkedList", "addAtIndex", "addAtIndex", "addAtIndex", "get"] [[], [0, 10], [0, 20], [1, 30], [0]]

› Output: [null, null, null, null, 20]

💡 Note: Add 10 at index 0: [10] → Add 20 at index 0: [20,10] → Add 30 at index 1: [20,30,10] → Get index 0: returns 20

example_3.py — Invalid Operations

$ Input: ["MyLinkedList", "get", "addAtIndex", "get", "get", "addAtIndex"] [[], [0], [0, 1], [0], [1], [2, 2]]

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

💡 Note: Get from empty list returns -1 → Add 1 at index 0: [1] → Get index 0: returns 1 → Get index 1: returns -1 (out of bounds) → Add at index 2: no change (index too large)

Constraints

0 ≤ index, val ≤ 1000
Please do not use the built-in LinkedList library
At most 2000 calls will be made to get, addAtHead, addAtTail, addAtIndex, and deleteAtIndex

Visualization

Tap to expand

Understanding the Visualization

Singly Linked List

Basic implementation with head pointer only

Add Dummy Head

Eliminates special cases for head operations

Doubly Linked

Add prev pointers for bidirectional traversal

Dummy Tail + Optimization

Add dummy tail and smart traversal for optimal performance

Key Takeaway

🎯 Key Insight: Using dummy nodes and bidirectional pointers transforms a simple linked list into a highly efficient data structure with uniform operation handling.

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28

The optimal solution uses a doubly linked list with dummy head and tail nodes. Key insights: dummy nodes eliminate edge cases, bidirectional traversal allows choosing the shorter path to any index, and maintaining size counter enables quick boundary checks. This achieves O(1) operations at both ends and O(min(k, n-k)) for middle operations.

Common Approaches

Approach	Time	Space	Notes
✓ Doubly Linked List with Tail Pointer (Optimal)	O(min(index, n-index))	O(1)	Doubly linked list with both head and tail pointers for O(1) operations at both ends
Singly Linked List with Array-like Operations	O(n)	O(1)	Basic singly linked list implementation traversing from head for each operation

Doubly Linked List with Tail Pointer (Optimal) — Algorithm Steps

Define a Node class with val, next, and prev attributes
Use dummy head and tail nodes to eliminate edge cases
Maintain size counter for quick boundary checks
For middle operations, choose shorter path (from head or tail)
Update both next and prev pointers during modifications

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create dummy head and tail nodes connected to each other

Smart Traversal

Choose to traverse from head or tail based on index position

Bidirectional Updates

Update both next and prev pointers during modifications

Code -

solution.c — C

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

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

typedef struct {
    ListNode* head;
    ListNode* tail;
    int size;
} MyLinkedList;

ListNode* createNode(int val) {
    ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    node->val = val;
    node->next = NULL;
    node->prev = NULL;
    return node;
}

void addNode(MyLinkedList* obj, ListNode* prevNode, ListNode* nextNode, int val) {
    ListNode* newNode = createNode(val);
    newNode->prev = prevNode;
    newNode->next = nextNode;
    prevNode->next = newNode;
    nextNode->prev = newNode;
    obj->size++;
}

void removeNode(MyLinkedList* obj, ListNode* node) {
    node->prev->next = node->next;
    node->next->prev = node->prev;
    free(node);
    obj->size--;
}

MyLinkedList* myLinkedListCreate() {
    MyLinkedList* obj = (MyLinkedList*)malloc(sizeof(MyLinkedList));
    obj->head = createNode(0); // dummy head
    obj->tail = createNode(0); // dummy tail
    obj->head->next = obj->tail;
    obj->tail->prev = obj->head;
    obj->size = 0;
    return obj;
}

int myLinkedListGet(MyLinkedList* obj, int index) {
    if (index < 0 || index >= obj->size) {
        return -1;
    }
    
    ListNode* current;
    if (index < obj->size / 2) {
        current = obj->head->next;
        for (int i = 0; i < index; i++) {
            current = current->next;
        }
    } else {
        current = obj->tail->prev;
        for (int i = 0; i < obj->size - 1 - index; i++) {
            current = current->prev;
        }
    }
    
    return current->val;
}

void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    addNode(obj, obj->head, obj->head->next, val);
}

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    addNode(obj, obj->tail->prev, obj->tail, val);
}

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    if (index > obj->size) return;
    if (index < 0) index = 0;
    
    if (index == 0) {
        myLinkedListAddAtHead(obj, val);
    } else if (index == obj->size) {
        myLinkedListAddAtTail(obj, val);
    } else {
        ListNode* current;
        if (index < obj->size / 2) {
            current = obj->head;
            for (int i = 0; i < index; i++) {
                current = current->next;
            }
        } else {
            current = obj->tail;
            for (int i = 0; i < obj->size - index + 1; i++) {
                current = current->prev;
            }
        }
        
        addNode(obj, current, current->next, val);
    }
}

void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    if (index < 0 || index >= obj->size) return;
    
    ListNode* current;
    if (index < obj->size / 2) {
        current = obj->head->next;
        for (int i = 0; i < index; i++) {
            current = current->next;
        }
    } else {
        current = obj->tail->prev;
        for (int i = 0; i < obj->size - 1 - index; i++) {
            current = current->prev;
        }
    }
    
    removeNode(obj, current);
}

Time & Space Complexity

Time Complexity

⏱️

O(min(index, n-index))

Can traverse from either end, choosing the shorter path to the target

✓ Linear Growth

Space Complexity

O(1)

Constant extra space for operations, regardless of list size

✓ Linear Space

89.5K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Doubly Linked List with Tail Pointer (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler