Add Two Numbers II - Practice Coding Problems

Add Two Numbers II - Problem

Imagine you have two large numbers written on paper, but instead of storing them as regular integers, each digit is stored in a separate box (node) of a linked list. The twist? The most significant digit comes first - just like how we normally write numbers!

You're given two non-empty linked lists representing two non-negative integers. Each node contains a single digit (0-9), and you need to add these two numbers together and return the sum as a new linked list.

For example:

Number 1: 7 → 2 → 4 → 3 represents 7243
Number 2: 5 → 6 → 4 represents 564
Sum: 7 → 8 → 0 → 7 represents 7807

The challenge is that we can't simply reverse the lists (like in Add Two Numbers I) because we need to maintain the original structure. We need to handle carries that propagate from right to left, just like elementary school addition!

Input & Output

example_1.py — Basic Addition

$ Input: l1 = [7,2,4,3], l2 = [5,6,4]

› Output: [7,8,0,7]

💡 Note: 7243 + 564 = 7807. The digits are stored with most significant digit first.

example_2.py — Addition with Carry

$ Input: l1 = [2,4,3], l2 = [5,6,4]

› Output: [8,0,7]

💡 Note: 243 + 564 = 807. Notice how the carry propagates from right to left.

example_3.py — Single Digits

$ Input: l1 = [0], l2 = [0]

› Output: [0]

💡 Note: 0 + 0 = 0. Edge case with single zero digits.

Visualization

Tap to expand

Understanding the Visualization

Load the Stacks

Push all digits from both numbers onto separate stacks, naturally reversing their order

Add from Right to Left

Pop digits from stacks and add them with any carry from the previous addition

Handle the Carry

If sum ≥ 10, carry the 1 to the next position and keep the remainder digit

Build Result List

Create new nodes and prepend them to build the final result list

Key Takeaway

🎯 Key Insight: Stacks naturally reverse the digit order, letting us perform elementary school addition (right-to-left) while keeping the original linked lists intact!

Time & Space Complexity

Time Complexity

⏱️

O(max(n, m))

Need to traverse both lists once to fill stacks, then process all digits once more

✓ Linear Growth

Space Complexity

O(n + m)

Space for two stacks to hold all digits from both lists

⚡ Linearithmic Space

Constraints

The number of nodes in each linked list is in the range [1, 100]
0 ≤ Node.val ≤ 9
The input represents a valid number without leading zeros
Follow up: Could you solve it without reversing the input lists?

Asked in

a Amazon 45 ⊞ Microsoft 38 Apple 32 G Google 28

The optimal approach uses stacks to reverse the digit order naturally. Push all digits from both linked lists onto stacks, then pop and add them while handling carry propagation properly. This avoids integer overflow issues and demonstrates proper linked list manipulation with O(max(n,m)) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Stack-Based Addition (Optimal)	O(max(n, m))	O(n + m)	Use stacks to reverse digit order, then add with carry propagation

Stack-Based Addition (Optimal) — Algorithm Steps

Push all digits from both linked lists onto separate stacks
Pop digits from both stacks and add them with carry
Handle carry propagation and build result list from right to left
Add any remaining carry as a new node

Visualization

Tap to expand

Step-by-Step Walkthrough

Fill Stacks

Push all digits from both lists onto stacks

Pop and Add

Pop digits from stacks and add with carry

Build Result

Create result list by prepending new nodes

Code -

solution.c — C

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

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

// Simple stack implementation
#define MAX_SIZE 10000
struct Stack {
    int data[MAX_SIZE];
    int top;
};

void push(struct Stack* stack, int val) {
    stack->data[++stack->top] = val;
}

int pop(struct Stack* stack) {
    return stack->data[stack->top--];
}

int isEmpty(struct Stack* stack) {
    return stack->top == -1;
}

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
    struct Stack stack1 = {.top = -1};
    struct Stack stack2 = {.top = -1};
    
    // Push all digits of l1 onto stack1
    struct ListNode* current = l1;
    while (current) {
        push(&stack1, current->val);
        current = current->next;
    }
    
    // Push all digits of l2 onto stack2
    current = l2;
    while (current) {
        push(&stack2, current->val);
        current = current->next;
    }
    
    int carry = 0;
    struct ListNode* head = NULL;
    
    // Process digits from right to left
    while (!isEmpty(&stack1) || !isEmpty(&stack2) || carry) {
        int digit1 = isEmpty(&stack1) ? 0 : pop(&stack1);
        int digit2 = isEmpty(&stack2) ? 0 : pop(&stack2);
        
        int total = digit1 + digit2 + carry;
        carry = total / 10;
        int digit = total % 10;
        
        // Create new node and prepend to result
        struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
        newNode->val = digit;
        newNode->next = head;
        head = newNode;
    }
    
    return head;
}

Time & Space Complexity

Time Complexity

⏱️

O(max(n, m))

Need to traverse both lists once to fill stacks, then process all digits once more

✓ Linear Growth

Space Complexity

O(n + m)

Space for two stacks to hold all digits from both lists

⚡ Linearithmic Space

Constraints

The number of nodes in each linked list is in the range [1, 100]
0 ≤ Node.val ≤ 9
The input represents a valid number without leading zeros
Follow up: Could you solve it without reversing the input lists?

68.0K Views

High Frequency

~18 min Avg. Time

1.5K 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

Stack-Based Addition (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler