Codestin Search App

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.

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

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!

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
✓ 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
Digit-by-Digit Addition (Optimal)	O(max(m,n))	O(max(m,n))	Add digit by digit with carry, build result simultaneously
Digit-by-Digit Addition (Optimal)	O(max(m,n))	O(max(m,n))	Add corresponding digits while traversing both lists simultaneously
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

Convert to Numbers (Brute Force) — Algorithm Steps

Traverse first linked list and convert to integer
Traverse second linked list and convert to integer
Add the two integers together
Convert the sum back to a linked list in reverse order

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert Lists to Numbers

Extract integer values from both linked lists

Add Numbers

Perform regular integer addition

Convert Back to List

Create new linked list from the sum

Code -

solution.c — C

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

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

long long listToNum(struct ListNode* head) {
    long long num = 0;
    long long multiplier = 1;
    while (head) {
        num += head->val * multiplier;
        multiplier *= 10;
        head = head->next;
    }
    return num;
}

struct ListNode* numToList(long long num) {
    if (num == 0) {
        struct ListNode* node = malloc(sizeof(struct ListNode));
        node->val = 0;
        node->next = NULL;
        return node;
    }
    
    struct ListNode* dummy = malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = NULL;
    struct ListNode* current = dummy;
    
    while (num > 0) {
        int digit = num % 10;
        current->next = malloc(sizeof(struct ListNode));
        current->next->val = digit;
        current->next->next = NULL;
        current = current->next;
        num /= 10;
    }
    
    struct ListNode* result = dummy->next;
    free(dummy);
    return result;
}

struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
    long long num1 = listToNum(l1);
    long long num2 = listToNum(l2);
    long long total = num1 + num2;
    
    return numToList(total);
}

Time & Space Complexity

Time Complexity

⏱️

O(max(m,n))

We traverse each list once to convert, then traverse once more to build result

✓ Linear Growth

Space Complexity

O(max(m,n))

Space for the result linked list

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Convert to Numbers (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler