Plus One Linked List

Plus One Linked List - Problem

Given a non-negative integer represented as a linked list of digits, plus one to the integer.

The digits are stored such that the most significant digit is at the head of the list.

For example, the number 123 is stored as 1 → 2 → 3.

Goal: Add 1 to this number and return the modified linked list.

Input & Output

Example 1 — Basic Addition

$ Input: head = [1,2,3]

› Output: [1,2,4]

💡 Note: The number is 123, plus one gives 124, represented as 1→2→4

Example 2 — Carry Propagation

$ Input: head = [4,3,2,1]

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

💡 Note: The number is 4321, plus one gives 4322, represented as 4→3→2→2

Example 3 — All Nines

$ Input: head = [9,9,9]

› Output: [1,0,0,0]

💡 Note: The number is 999, plus one gives 1000, requiring a new head node: 1→0→0→0

Constraints

1 ≤ Number of nodes ≤ 100
0 ≤ Node.val ≤ 9
The number does not have leading zeros, except the number 0 itself

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 6

The key insight is handling carry propagation from right to left in a linked list. The recursive approach elegantly reaches the end first, then propagates carry back. Best approach: Recursive Carry - Time: O(n), Space: O(n)

Common Approaches

✓ Convert to Integer

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

Traverse the linked list to build the complete number as an integer, add 1 to it, then create a new linked list from the result digits.

Recursive Carry

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

Recursively traverse to the end of the list, then propagate carry back from the least significant digit. If final carry exists, create new head node.

Convert to Integer — Algorithm Steps

Step 1: Traverse linked list and build integer value
Step 2: Add 1 to the integer
Step 3: Convert result back to linked list

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Integer

Read digits left-to-right: 1→2→3 becomes 123

Add One

123 + 1 = 124

Rebuild List

Convert 124 back to 1→2→4

Code -

solution.c — C

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

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

struct ListNode* solution(struct ListNode* head) {
    if (!head) {
        struct ListNode* newNode = malloc(sizeof(struct ListNode));
        newNode->val = 1;
        newNode->next = NULL;
        return newNode;
    }
    
    // Convert to long long
    long long num = 0;
    struct ListNode* current = head;
    while (current) {
        num = num * 10 + current->val;
        current = current->next;
    }
    
    // Add 1
    num += 1;
    
    // Convert back to linked list
    if (num == 0) {
        struct ListNode* newNode = malloc(sizeof(struct ListNode));
        newNode->val = 0;
        newNode->next = NULL;
        return newNode;
    }
    
    struct ListNode* prev = NULL;
    while (num > 0) {
        int digit = num % 10;
        struct ListNode* node = malloc(sizeof(struct ListNode));
        node->val = digit;
        node->next = prev;
        prev = node;
        num /= 10;
    }
    
    return prev;
}

struct ListNode* arrayToList(int* arr, int size) {
    if (size == 0) return NULL;
    struct ListNode* head = malloc(sizeof(struct ListNode));
    head->val = arr[0];
    head->next = NULL;
    struct ListNode* current = head;
    for (int i = 1; i < size; i++) {
        current->next = malloc(sizeof(struct ListNode));
        current->next->val = arr[i];
        current->next->next = NULL;
        current = current->next;
    }
    return head;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int arr[100];
    int size = 0;
    char* ptr = line + 1; // Skip '['
    while (*ptr != ']') {
        if (*ptr >= '0' && *ptr <= '9') {
            arr[size++] = *ptr - '0';
        }
        ptr++;
    }
    
    struct ListNode* head = arrayToList(arr, size);
    struct ListNode* result = solution(head);
    
    // Print result
    printf("[");
    struct ListNode* current = result;
    int first = 1;
    while (current) {
        if (!first) printf(",");
        printf("%d", current->val);
        first = 0;
        current = current->next;
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to read digits plus single pass to create result

✓ Linear Growth

Space Complexity

O(n)

Creates new linked list for result

⚡ Linearithmic Space

32.0K Views

Medium 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Convert to Integer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler