Singly Linked List - Problem

Implement a singly linked list data structure with the following operations:

Insert at head: Add a new node at the beginning
Insert at tail: Add a new node at the end
Insert at position: Add a new node at a specific index
Delete by value: Remove the first node with given value
Search: Find if a value exists in the list
Display: Return all values as an array

For this problem, you'll implement the insert_head operation. Given an array representing the current linked list and a value to insert, return the array representation after inserting the value at the head.

Input & Output

Example 1 — Basic Insertion

$ Input: list = [2,3,4], value = 1

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

💡 Note: Insert 1 at the head: the new list becomes [1,2,3,4] with 1 at the front

Example 2 — Empty List

$ Input: list = [], value = 5

› Output: [5]

💡 Note: Inserting 5 into an empty list results in [5]

Example 3 — Single Element

$ Input: list = [10], value = 7

› Output: [7,10]

💡 Note: Insert 7 at head of [10] gives [7,10]

Constraints

0 ≤ list.length ≤ 10³
-10³ ≤ list[i] ≤ 10³
-10³ ≤ value ≤ 10³

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 30 M Microsoft 20 🍎 Apple 15

The key insight is that inserting at the head of a singly linked list (represented as array) requires creating a new array with the new element first, followed by all existing elements. Best approach uses built-in array operations for cleaner code. Time: O(n), Space: O(n)

Common Approaches

✓ Built-in Array Operations

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

Instead of manually creating and copying arrays, use language built-in methods like array concatenation, unshift, or list prepending to add the new element at the beginning.

Copy All Elements

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

Create a result array of size n+1, place the new value at index 0, then iterate through the original array copying each element to the next position in the result array.

Built-in Array Operations — Algorithm Steps

Step 1: Create array/list with just the new value
Step 2: Use built-in concatenation to combine with original array
Step 3: Return the concatenated result

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Single Element

Start with array containing just new value

Concatenate Arrays

Use built-in concat/spread operations

Return Result

Get combined array efficiently

Code -

solution.c — C

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

int* solution(int* listArr, int listSize, int value, int* returnSize) {
    // Use realloc to efficiently manage memory
    int* result = (int*)malloc((listSize + 1) * sizeof(int));
    *returnSize = listSize + 1;
    
    result[0] = value;
    memcpy(result + 1, listArr, listSize * sizeof(int));
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array - simple parsing for [1,2,3] format
    int listArr[100];
    int listSize = 0;
    
    if (strlen(line) > 3) { // More than just []
        char* ptr = line + 1; // Skip opening bracket
        char* token = strtok(ptr, ",]");
        while (token != NULL) {
            listArr[listSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    int value;
    scanf("%d", &value);
    
    int returnSize;
    int* result = solution(listArr, listSize, value, &returnSize);
    
    // Print result
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Built-in operations still need to shift all existing elements

✓ Linear Growth

Space Complexity

O(n)

Creates new array containing all n+1 elements

⚡ Linearithmic Space

28.5K Views

High Frequency

~15 min Avg. Time

890 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

Singly Linked List - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Built-in Array Operations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler