Codestin Search App

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)

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.

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

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

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
✓ 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)	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 — Algorithm Steps

Define a Node class with val and next attributes
Initialize with a dummy head node to simplify edge cases
For get/add/delete operations, traverse from head to find the target position
Handle boundary checks for invalid indices
Update next pointers carefully during insertions and deletions

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create dummy head node for easier operations

Add at Index

Traverse to position and insert new node

Delete at Index

Find node and update pointers to skip it

Code -

solution.c — C

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

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

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

MyLinkedList* myLinkedListCreate() {
    MyLinkedList* obj = (MyLinkedList*)malloc(sizeof(MyLinkedList));
    obj->head = (ListNode*)malloc(sizeof(ListNode)); // dummy head
    obj->head->val = 0;
    obj->head->next = NULL;
    obj->size = 0;
    return obj;
}

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

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val);

void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
    myLinkedListAddAtIndex(obj, 0, val);
}

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
    myLinkedListAddAtIndex(obj, obj->size, val);
}

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
    if (index > obj->size) return;
    if (index < 0) index = 0;
    
    ListNode* current = obj->head;
    for (int i = 0; i < index; i++) {
        current = current->next;
    }
    
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->val = val;
    newNode->next = current->next;
    current->next = newNode;
    obj->size++;
}

void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
    if (index < 0 || index >= obj->size) return;
    
    ListNode* current = obj->head;
    for (int i = 0; i < index; i++) {
        current = current->next;
    }
    
    ListNode* toDelete = current->next;
    current->next = current->next->next;
    free(toDelete);
    obj->size--;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each operation may require traversing up to n nodes to reach the target position

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for pointers during operations

✓ Linear Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Singly Linked List with Array-like Operations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler