Double a Number Represented as a Linked List

Double a Number Represented as a Linked List - Problem

Imagine you have a giant number so large that it can't fit in a regular integer variable - maybe it has hundreds of digits! This number is stored as a linked list, where each node contains a single digit, and the digits are arranged from most significant to least significant (left to right).

Your task is to double this enormous number and return the result as a linked list in the same format. The input is guaranteed to represent a non-negative integer without leading zeros.

Example: If the linked list represents 123, after doubling it should represent 246.

Think of it like using an old-fashioned calculator that can only display one digit at a time, but you need to double a number that's way too big for any calculator!

Input & Output

example_1.py — Basic Doubling

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

› Output: [3,7,8]

💡 Note: The number 189 doubled is 378. Each digit is stored in a separate node: 1→8→9 becomes 3→7→8

example_2.py — Single Digit

$ Input: head = [9]

› Output: [1,8]

💡 Note: The number 9 doubled is 18. Since the result has two digits, we need two nodes: 9 becomes 1→8

example_3.py — Multiple Carries

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

› Output: [1,9,9,8]

💡 Note: The number 999 doubled is 1998. Multiple carries propagate: 9×2=18, carry 1; 9×2+1=19, carry 1; 9×2+1=19, carry 1; final carry becomes new head

Constraints

The number of nodes in the list is in the range [1, 10⁴]
0 ≤ Node.val ≤ 9
The input represents a valid number without leading zeros
The linked list represents a non-negative integer

Visualization

Tap to expand

Understanding the Visualization

Identify the Problem

Doubling 567 should give 1134, but carries make it tricky

Traditional Approach

Process right-to-left like manual arithmetic (requires stack/reversal)

Clever Insight

Process left-to-right by predicting which digits will generate carries

Optimal Solution

Single pass with lookahead: if next digit ≥ 5, current gets +1 carry

Key Takeaway

🎯 Key Insight: By checking if the next digit ≥ 5, we can predict carries and process left-to-right in a single pass, achieving optimal O(n) time and O(1) space complexity!

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 15

The optimal approach uses a single-pass traversal with carry lookahead. First check if the most significant digit ≥ 5 to determine if a new head is needed. Then traverse once, doubling each digit and using the key insight: if the next digit ≥ 5, it will generate a carry when doubled, so add 1 to the current result. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Digit Processing	O(n)	O(n)	Use a stack to reverse digits, then process from right to left with carry
Single Pass with Carry Lookahead (Optimal)	O(n)	O(1)	Check if first digit needs carry, then process in one forward pass

Stack-Based Digit Processing — Algorithm Steps

Push all linked list digits onto a stack
Pop digits one by one (now in reverse order)
For each digit: multiply by 2, add any carry from previous step
Handle carry propagation and build result linked list
Add final carry digit if needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Push to Stack

Push all digits onto stack (reversing order)

Pop and Double

Pop digits, double them, handle carries

Build Result

Create new linked list with doubled values

Code -

solution.c — C

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

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

struct ListNode* doubleIt(struct ListNode* head) {
    // Count nodes first
    int count = 0;
    struct ListNode* current = head;
    while (current) {
        count++;
        current = current->next;
    }
    
    // Create stack array
    int* stack = malloc(count * sizeof(int));
    int top = -1;
    
    // Push all digits onto stack
    current = head;
    while (current) {
        stack[++top] = current->val;
        current = current->next;
    }
    
    int carry = 0;
    struct ListNode* result = NULL;
    
    // Process digits from right to left
    while (top >= 0 || carry) {
        int digit = (top >= 0) ? stack[top--] : 0;
        int doubled = digit * 2 + carry;
        carry = doubled / 10;
        int digitVal = doubled % 10;
        
        // Build result linked list (prepend)
        struct ListNode* newNode = malloc(sizeof(struct ListNode));
        newNode->val = digitVal;
        newNode->next = result;
        result = newNode;
    }
    
    free(stack);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

One pass to fill stack, one pass to process digits

✓ Linear Growth

Space Complexity

O(n)

Stack stores all n digits

⚡ Linearithmic Space

28.4K Views

Medium-High Frequency

~15 min Avg. Time

847 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

Stack-Based Digit Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler