Add Two Polynomials Represented as Linked Lists

Add Two Polynomials Represented as Linked Lists - Problem

Imagine you're working with polynomial expressions like 5x³ + 4x - 7, but instead of storing them as strings, you represent them using linked lists where each node contains a coefficient and power.

A polynomial linked list is a special data structure where:

coefficient: The number multiplier (e.g., in 9x⁴, coefficient = 9)
power: The exponent (e.g., in 9x⁴, power = 4)
next: Pointer to the next term

The polynomial 5x³ + 4x - 7 would be represented as: [[5,3], [4,1], [-7,0]]

Rules:

Terms must be in strictly descending order by power
Terms with coefficient 0 are omitted
Standard mathematical form is maintained

Your task: Given two polynomial linked lists poly1 and poly2, add them together and return the head of the resulting polynomial in proper form.

Input & Output

example_1.py — Basic Addition

$ Input: poly1 = [[1,1]], poly2 = [[1,0]]

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

💡 Note: Adding x + 1 gives us x + 1. Since the powers are different (1 and 0), we keep both terms in descending order.

example_2.py — Combining Like Terms

$ Input: poly1 = [[2,2],[4,1],[3,0]], poly2 = [[3,2],[-4,1],[-1,0]]

› Output: [[5,2],[2,0]]

💡 Note: Adding (2x² + 4x + 3) + (3x² - 4x - 1) = 5x² + 2. The x terms cancel out (4x - 4x = 0) and are omitted.

example_3.py — Complete Cancellation

$ Input: poly1 = [[1,2]], poly2 = [[-1,2]]

› Output: []

💡 Note: Adding x² + (-x²) = 0. Since the result has no non-zero terms, we return an empty polynomial.

Constraints

0 ≤ m, n ≤ 10⁴ where m and n are the lengths of poly1 and poly2
-10⁹ ≤ coefficient ≤ 10⁹
0 ≤ power ≤ 10⁹
Both polynomials are in descending order by power
No terms have coefficient 0 in the input

Visualization

Tap to expand

Understanding the Visualization

Set Up Recipe Cards

Place both polynomial recipes side by side, each sorted by ingredient complexity

Compare Current Ingredients

Look at the current ingredient from each recipe and compare their types (powers)

Combine or Choose

If ingredients match, add their amounts; otherwise take the more complex ingredient

Move to Next

Advance to the next ingredient in the appropriate recipe(s)

Finish Remaining

Add any remaining ingredients from the non-empty recipe

Key Takeaway

🎯 Key Insight: Since both polynomials are pre-sorted by power, we can merge them in one pass like merging sorted arrays, achieving optimal O(m + n) time complexity.

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 18 f Meta 15

The optimal approach uses two pointers to merge the sorted polynomial linked lists in O(m + n) time. Since both polynomials are already sorted by power in descending order, we can compare powers at each step and either combine coefficients for matching powers or take the term with higher power, similar to merging two sorted arrays.

Common Approaches

Approach	Time	Space	Notes
✓ Convert to Array and Reconstruct	O((m + n) log(m + n))	O(m + n)	Convert both linked lists to arrays, combine terms, then rebuild the linked list
Two Pointers Merge (Optimal)	O(m + n)	O(1)	Merge two sorted linked lists using two pointers, like merging sorted arrays

Convert to Array and Reconstruct — Algorithm Steps

Convert both linked lists to arrays of [coefficient, power] pairs
Create a map to store combined coefficients for each power
Iterate through both arrays and sum coefficients for matching powers
Sort the result by power in descending order
Reconstruct the linked list from the sorted array
Skip terms where coefficient becomes 0

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Arrays

Extract terms from both linked lists into arrays

Combine Terms

Use map/dictionary to sum coefficients for matching powers

Sort by Power

Sort combined terms in descending order by power

Rebuild List

Construct new linked list from sorted terms

Code -

solution.c — C

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

// Definition for polynomial node
typedef struct PolyNode {
    int coefficient;
    int power;
    struct PolyNode* next;
} PolyNode;

// Helper structure for sorting
typedef struct {
    int power;
    int coefficient;
} Term;

// Comparison function for qsort (descending by power)
int comparePowers(const void* a, const void* b) {
    Term* termA = (Term*)a;
    Term* termB = (Term*)b;
    return termB->power - termA->power;
}

PolyNode* addPoly(PolyNode* poly1, PolyNode* poly2) {
    // Array to store terms (assuming max power is reasonable)
    Term terms[1000];
    int termCount = 0;
    int powerExists[2001]; // Assuming powers range from -1000 to 1000
    int coefficients[2001];
    
    // Initialize arrays
    for (int i = 0; i < 2001; i++) {
        powerExists[i] = 0;
        coefficients[i] = 0;
    }
    
    // Process first polynomial
    PolyNode* current = poly1;
    while (current) {
        int index = current->power + 1000; // Offset for negative powers
        coefficients[index] += current->coefficient;
        powerExists[index] = 1;
        current = current->next;
    }
    
    // Process second polynomial
    current = poly2;
    while (current) {
        int index = current->power + 1000;
        coefficients[index] += current->coefficient;
        powerExists[index] = 1;
        current = current->next;
    }
    
    // Collect non-zero terms
    for (int i = 0; i < 2001; i++) {
        if (powerExists[i] && coefficients[i] != 0) {
            terms[termCount].power = i - 1000;
            terms[termCount].coefficient = coefficients[i];
            termCount++;
        }
    }
    
    // Sort terms by power (descending)
    qsort(terms, termCount, sizeof(Term), comparePowers);
    
    // Build result linked list
    if (termCount == 0) return NULL;
    
    PolyNode* head = (PolyNode*)malloc(sizeof(PolyNode));
    head->coefficient = terms[0].coefficient;
    head->power = terms[0].power;
    head->next = NULL;
    
    current = head;
    for (int i = 1; i < termCount; i++) {
        current->next = (PolyNode*)malloc(sizeof(PolyNode));
        current = current->next;
        current->coefficient = terms[i].coefficient;
        current->power = terms[i].power;
        current->next = NULL;
    }
    
    return head;
}

Time & Space Complexity

Time Complexity

⏱️

O((m + n) log(m + n))

Converting to arrays takes O(m + n), but sorting the combined result takes O((m + n) log(m + n)) time

⚡ Linearithmic

Space Complexity

O(m + n)

Need extra arrays to store all terms from both polynomials

⚡ Linearithmic Space

24.0K Views

Medium Frequency

~18 min Avg. Time

850 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 Array and Reconstruct — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler