Design Linked List

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

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

✓ Doubly Linked List with Tail Pointer (Optimal)

⏱️ Time: O(min(index, n-index)) Space: O(1)

Implement a doubly linked list where each node has both next and previous pointers, along with maintaining both head and tail references. This allows O(1) insertions and deletions at both ends.

Singly Linked List with Array-like Operations

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

Implement a singly linked list where we traverse from the head node for every operation. This is the most straightforward approach but not the most efficient for operations at the tail.

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>
#include <string.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);
}

int main() {
    char operations[10000], values[10000];
    fgets(operations, sizeof(operations), stdin);
    fgets(values, sizeof(values), stdin);
    
    // Remove newlines
    operations[strcspn(operations, "\n")] = 0;
    values[strcspn(values, "\n")] = 0;
    
    // Parse operations
    char* ops[1000];
    int opCount = 0;
    char* token = strtok(operations, ",");
    while (token != NULL) {
        ops[opCount++] = token;
        token = strtok(NULL, ",");
    }
    
    // Simple parsing for values - this is a basic implementation
    int vals[1000][2];
    int valCount = 0;
    char* ptr = values + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            if (*ptr == ']') {
                // Empty array
                vals[valCount][0] = -999; // marker for empty
                vals[valCount][1] = -999;
                ptr++;
            } else {
                // Parse numbers
                vals[valCount][0] = strtol(ptr, &ptr, 10);
                if (*ptr == ',') {
                    ptr++;
                    vals[valCount][1] = strtol(ptr, &ptr, 10);
                } else {
                    vals[valCount][1] = -999; // marker for single value
                }
                while (*ptr && *ptr != ']') ptr++;
                if (*ptr == ']') ptr++;
            }
            valCount++;
        } else {
            ptr++;
        }
    }
    
    printf("[");
    MyLinkedList* obj = NULL;
    
    for (int i = 0; i < opCount; i++) {
        if (i > 0) printf(", ");
        
        if (strcmp(ops[i], "MyLinkedList") == 0) {
            obj = myLinkedListCreate();
            printf("null");
        } else if (strcmp(ops[i], "addAtHead") == 0) {
            myLinkedListAddAtHead(obj, vals[i][0]);
            printf("null");
        } else if (strcmp(ops[i], "addAtTail") == 0) {
            myLinkedListAddAtTail(obj, vals[i][0]);
            printf("null");
        } else if (strcmp(ops[i], "addAtIndex") == 0) {
            myLinkedListAddAtIndex(obj, vals[i][0], vals[i][1]);
            printf("null");
        } else if (strcmp(ops[i], "deleteAtIndex") == 0) {
            myLinkedListDeleteAtIndex(obj, vals[i][0]);
            printf("null");
        } else if (strcmp(ops[i], "get") == 0) {
            int result = myLinkedListGet(obj, vals[i][0]);
            printf("%d", result);
        }
    }
    printf("]\n");
    
    return 0;
}

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