Add Two Numbers II

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.

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?

Visualization

Tap to expand

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

✓ Two Pointers

⏱️ Time: N/A Space: N/A

Stack-Based Addition (Optimal)

⏱️ Time: O(max(n, m)) Space: O(n + m)

Since we need to add from right to left but the lists start from left, we can use stacks to reverse the order. Push all digits onto stacks, then pop and add them while handling carries properly.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct PolyNode {
    int coefficient;
    int power;
    struct PolyNode* next;
};

struct PolyNode* createNode(int coeff, int power) {
    struct PolyNode* node = malloc(sizeof(struct PolyNode));
    node->coefficient = coeff;
    node->power = power;
    node->next = NULL;
    return node;
}

int parsePolynomial(char* input, int*** poly) {
    if (strcmp(input, "[]") == 0) {
        *poly = NULL;
        return 0;
    }
    
    int count = 0;
    char* temp = strdup(input);
    char* ptr = temp;
    
    // Count terms
    while (*ptr) {
        if (*ptr == '[') count++;
        ptr++;
    }
    
    *poly = malloc(count * sizeof(int*));
    
    int index = 0;
    ptr = temp + 1; // Skip first '['
    
    while (index < count) {
        // Find next term
        char* start = strchr(ptr, '[');
        if (!start) break;
        
        char* end = strchr(start, ']');
        if (!end) break;
        
        // Extract coefficient and power
        char term[100];
        strncpy(term, start + 1, end - start - 1);
        term[end - start - 1] = '\0';
        
        char* comma = strchr(term, ',');
        *comma = '\0';
        
        (*poly)[index] = malloc(2 * sizeof(int));
        (*poly)[index][0] = atoi(term);
        (*poly)[index][1] = atoi(comma + 1);
        
        index++;
        ptr = end + 1;
    }
    
    free(temp);
    return count;
}

int** solution(int** poly1, int poly1Size, int** poly2, int poly2Size, int* returnSize) {
    int maxSize = poly1Size + poly2Size;
    int** result = malloc(maxSize * sizeof(int*));
    int count = 0;
    
    int i = 0, j = 0;
    while (i < poly1Size && j < poly2Size) {
        if (poly1[i][1] > poly2[j][1]) {
            result[count] = malloc(2 * sizeof(int));
            result[count][0] = poly1[i][0];
            result[count][1] = poly1[i][1];
            i++;
        } else if (poly1[i][1] < poly2[j][1]) {
            result[count] = malloc(2 * sizeof(int));
            result[count][0] = poly2[j][0];
            result[count][1] = poly2[j][1];
            j++;
        } else {
            int coeffSum = poly1[i][0] + poly2[j][0];
            if (coeffSum != 0) {
                result[count] = malloc(2 * sizeof(int));
                result[count][0] = coeffSum;
                result[count][1] = poly1[i][1];
                count++;
            }
            i++;
            j++;
            continue;
        }
        count++;
    }
    
    while (i < poly1Size) {
        result[count] = malloc(2 * sizeof(int));
        result[count][0] = poly1[i][0];
        result[count][1] = poly1[i][1];
        i++;
        count++;
    }
    
    while (j < poly2Size) {
        result[count] = malloc(2 * sizeof(int));
        result[count][0] = poly2[j][0];
        result[count][1] = poly2[j][1];
        j++;
        count++;
    }
    
    *returnSize = count;
    return result;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int** poly1;
    int** poly2;
    int poly1Size = parsePolynomial(line1, &poly1);
    int poly2Size = parsePolynomial(line2, &poly2);
    
    int returnSize;
    int** result = solution(poly1, poly1Size, poly2, poly2Size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d]", result[i][0], result[i][1]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

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