Plus One Linked List - Practice Coding Problems

Plus One Linked List - Problem

Plus One to a Linked List Integer

Imagine you have a large number represented as a linked list where each node contains a single digit. The most significant digit (leftmost) is at the head of the list, and the least significant digit (rightmost) is at the tail.

Your task is to add 1 to this number and return the modified linked list. This might seem simple, but there's a catch - you need to handle carry operations just like in elementary arithmetic!

Example:
Input: 2 → 4 → 3 (represents 243)
Output: 2 → 4 → 4 (represents 244)

Challenge: What happens when you need to carry? For instance, 9 → 9 → 9 becomes 1 → 0 → 0 → 0!

Input & Output

example_1.py — Basic Addition

$ Input: head = [2,4,3] (represents 243)

› Output: [2,4,4] (represents 244)

💡 Note: Simple case where adding 1 doesn't cause any carry. The last digit 3 becomes 4, and all other digits remain unchanged.

example_2.py — Single Carry

$ Input: head = [1,2,9] (represents 129)

› Output: [1,3,0] (represents 130)

💡 Note: Adding 1 to 9 creates a carry. The 9 becomes 0, the carry propagates to make 2 become 3, and no further carries are needed.

example_3.py — Multiple Carries

$ Input: head = [9,9,9] (represents 999)

› Output: [1,0,0,0] (represents 1000)

💡 Note: Worst case scenario where all digits are 9. Adding 1 causes carries to propagate through all digits, requiring a new head node to be created.

Visualization

Tap to expand

Understanding the Visualization

Reach the End

Recursion goes deep until it hits null, then returns carry=1

Process Each Digit

Each level adds carry to its digit, updates value, returns new carry

Handle Final Carry

If final carry exists, create new head node for the extra digit

Key Takeaway

🎯 Key Insight: Recursion provides a natural way to process linked lists from right to left, making carry propagation intuitive and eliminating the need for extra data structures.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all n nodes of the linked list

✓ Linear Growth

Space Complexity

O(n)

Recursion uses O(n) call stack space, but no additional data structures

⚡ Linearithmic Space

Constraints

The number of nodes in the linked list is in the range [1, 100]
0 ≤ Node.val ≤ 9
The number represented by the linked list does not have leading zeros except for the number 0 itself
You may assume the input is always a valid non-negative integer

Asked in

G Google 42 f Facebook 28 a Amazon 35 ⊞ Microsoft 19

The optimal recursive solution elegantly handles carry propagation using the call stack. By processing digits from right to left through recursion, we can add one and handle carries in a single pass without extra space for digit storage. Key insight: recursion naturally provides the return path needed for carry propagation, making this approach both space-efficient and intuitive.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass with Stack/Array	O(n)	O(n)	Store all digits in array, then process from right to left with carry
Recursion (Optimal)	O(n)	O(n)	Use recursion to naturally handle carry propagation in one pass

Two-Pass with Stack/Array — Algorithm Steps

Traverse linked list and store all digits in an array
Start from the rightmost digit (least significant)
Add 1 to the last digit and handle carry propagation
Create new linked list from the modified array

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Digits

Read linked list into array: [2,4,3]

Add One

Process from right: 3+1=4, carry=0

Build Result

Create new linked list from array: [2,4,4]

Code -

solution.c — C

// Definition for singly-linked list.
struct ListNode {
    int val;
    struct ListNode *next;
};

struct ListNode* plusOne(struct ListNode* head) {
    // Step 1: Count nodes and store digits
    int count = 0;
    struct ListNode* current = head;
    while (current != NULL) {
        count++;
        current = current->next;
    }
    
    // Allocate array for digits
    int* digits = (int*)malloc(count * sizeof(int));
    current = head;
    for (int i = 0; i < count; i++) {
        digits[i] = current->val;
        current = current->next;
    }
    
    // Step 2: Add 1 from right to left with carry
    int carry = 1;
    for (int i = count - 1; i >= 0; i--) {
        int total = digits[i] + carry;
        digits[i] = total % 10;
        carry = total / 10;
        
        if (carry == 0) {
            break;
        }
    }
    
    // Step 3: Create new linked list
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = NULL;
    current = dummy;
    
    // If there's still a carry, add it as new head
    if (carry > 0) {
        struct ListNode* new_node = (struct ListNode*)malloc(sizeof(struct ListNode));
        new_node->val = carry;
        new_node->next = NULL;
        current->next = new_node;
        current = new_node;
    }
    
    // Add all digits
    for (int i = 0; i < count; i++) {
        struct ListNode* new_node = (struct ListNode*)malloc(sizeof(struct ListNode));
        new_node->val = digits[i];
        new_node->next = NULL;
        current->next = new_node;
        current = new_node;
    }
    
    struct ListNode* result = dummy->next;
    free(dummy);
    free(digits);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes: one to read digits into array, one to create result linked list

✓ Linear Growth

Space Complexity

O(n)

Need array to store all n digits plus space for result linked list

⚡ Linearithmic Space

Constraints

The number of nodes in the linked list is in the range [1, 100]
0 ≤ Node.val ≤ 9
The number represented by the linked list does not have leading zeros except for the number 0 itself
You may assume the input is always a valid non-negative integer

84.2K Views

Medium Frequency

~15 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

Two-Pass with Stack/Array — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler