Add Two Numbers - Practice Coding Problems

Add Two Numbers - Problem

Imagine you're building a calculator that works with really big numbers - so big that regular integers can't handle them! In this problem, you're given two numbers represented as linked lists, where each node contains a single digit, and the digits are stored in reverse order.

For example, the number 342 would be represented as 2 → 4 → 3 in the linked list.

Your task is to add these two numbers and return the result as a new linked list, also in reverse order. Don't forget to handle carry-over when the sum of two digits exceeds 9!

Goal: Add two numbers represented as reversed linked lists
Input: Two non-empty linked lists representing non-negative integers
Output: A new linked list representing the sum in reverse order

Input & Output

example_1.py — Basic Addition

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

› Output: [7,0,8]

💡 Note: 342 + 465 = 807. The linked lists represent numbers in reverse order, so we're actually adding 342 + 465 = 807, which becomes [7,0,8] in reverse order.

example_2.py — Different Lengths

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

› Output: [0]

💡 Note: Simple case: 0 + 0 = 0

example_3.py — Carry Propagation

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

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

💡 Note: 9999999 + 9999 = 10009998. Multiple carries propagate through the addition, resulting in a longer result list.

Visualization

Tap to expand

Understanding the Visualization

Start from the least significant digits

Both linked lists start with the ones place, making addition straightforward

Add digits and handle carry

Add current digits plus any carry from previous position

Create result node

Store the digit (sum % 10) and calculate new carry (sum / 10)

Continue until done

Process all digits and any final carry

Key Takeaway

🎯 Key Insight: The reverse order storage in linked lists perfectly matches how we perform manual addition - from right to left with carry propagation!

Time & Space Complexity

Time Complexity

⏱️

O(max(m,n))

We traverse both lists once, where m and n are the lengths of the two lists

✓ Linear Growth

Space Complexity

O(max(m,n))

Space for the result linked list, which has at most max(m,n)+1 nodes

⚡ Linearithmic Space

Constraints

The number of nodes in each linked list is in the range [1, 100]
0 ≤ Node.val ≤ 9
It is guaranteed that the list represents a number that does not have leading zeros
Both input lists are non-empty

Asked in

G Google 127 a Amazon 89 ⊞ Microsoft 76 f Meta 54

The optimal solution uses digit-by-digit addition with carry handling, mimicking elementary school arithmetic. We traverse both linked lists simultaneously, adding corresponding digits plus any carry from the previous position. This approach has O(max(m,n)) time complexity and handles arbitrarily large numbers without overflow issues, making it the preferred solution for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ Digit-by-Digit Addition (Optimal)	O(max(m,n))	O(max(m,n))	Add digit by digit with carry, build result simultaneously
Convert to Numbers (Brute Force)	O(max(m,n))	O(max(m,n))	Convert linked lists to integers, add them, convert back to linked list
Recursive Approach	O(max(m,n))	O(max(m,n))	Recursively add digits with carry propagation
Single Pass Addition (Optimal)	O(max(n,m))	O(max(n,m))	Simulate elementary addition with carry in one pass
Simultaneous Traversal with Carry	O(max(m,n))	O(max(m,n))	Traverse both lists simultaneously, handling digit addition and carry propagation
Digit-by-Digit Addition (Optimal)	O(max(m,n))	O(max(m,n))	Add corresponding digits while traversing both lists simultaneously

Digit-by-Digit Addition (Optimal) — Algorithm Steps

Create dummy node and current pointer
Initialize carry = 0
While l1 OR l2 OR carry exists:
sum = carry
If l1 exists: sum += l1.val, move l1
If l2 exists: sum += l2.val, move l2
carry = sum / 10
Create new node with sum % 10
Move current pointer forward
Return dummy.next

Visualization

Tap to expand

Step-by-Step Walkthrough

Process first digits: 2 + 5

Add 2 + 5 + carry(0) = 7. Carry = 0. Create node(7)

Process second digits: 4 + 6

Add 4 + 6 + carry(0) = 10. Carry = 1. Create node(0)

Process third digits: 3 + 4

Add 3 + 4 + carry(1) = 8. Carry = 0. Create node(8)

✅ Result: [7→0→8]

No more digits and carry = 0. Done!

Code -

solution.c — C

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode* dummy = (struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode* current = dummy;
    int carry = 0;
    
    while (l1 != NULL || l2 != NULL || carry != 0) {
        int sum = carry;
        
        if (l1 != NULL) {
            sum += l1->val;
            l1 = l1->next;
        }
        
        if (l2 != NULL) {
            sum += l2->val;
            l2 = l2->next;
        }
        
        carry = sum / 10;
        current->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        current->next->val = sum % 10;
        current->next->next = NULL;
        current = current->next;
    }
    
    return dummy->next;
}

Time & Space Complexity

Time Complexity

⏱️

O(max(m,n))

We traverse both lists simultaneously. The loop runs for max(m,n) iterations where m and n are the lengths of l1 and l2. Each iteration does O(1) work. Even with carry, we add at most one extra iteration.

✓ Linear Growth

Space Complexity

O(max(m,n))

We create a new linked list to store the result. The result has at most max(m,n)+1 nodes. We only use O(1) extra space for variables (carry, sum, pointers).

⚡ Linearithmic Space

Constraints

The number of nodes in each linked list is in the range [1, 100]
0 ≤ Node.val ≤ 9
It is guaranteed that the list represents a number that does not have leading zeros
Both input lists are non-empty

425.9K Views

Very High Frequency

~15 min Avg. Time

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

Digit-by-Digit Addition (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler