Polynomial Addition - Problem

Given two polynomials represented as linked lists, implement polynomial addition and return the result as a linked list.

Each node in the linked list contains:

coeff: coefficient of the term
exp: exponent of the term
next: pointer to next node

The polynomials are sorted in descending order of exponents.

Example: For polynomials 3x² + 5x + 2 and 4x² + 2x + 1, the result should be 7x² + 7x + 3.

Input & Output

Example 1 — Basic Addition

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

› Output: [[7,2],[7,1],[3,0]]

💡 Note: Adding polynomials 3x² + 5x + 2 and 4x² + 2x + 1: coefficients with same exponents are added (3+4=7, 5+2=7, 2+1=3)

Example 2 — Different Exponents

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

› Output: [[1,3],[2,2],[7,1]]

💡 Note: Adding x³ + 4x and 2x² + 3x: x³ and 2x² have no matching terms, x terms combine (4+3=7)

Example 3 — Coefficient Cancellation

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

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

💡 Note: Adding 5x² + 3x and -5x² + 2: the x² terms cancel out (5-5=0), leaving 3x + 2

Constraints

1 ≤ length of polynomial ≤ 100
-1000 ≤ coefficient ≤ 1000
0 ≤ exponent ≤ 100
Polynomials are sorted in descending order by exponent

Visualization

Tap to expand

Asked in

M Microsoft 15 Ad Adobe 12 S Samsung 8

The key insight is to treat polynomial addition like merging two sorted linked lists. Use two pointers to traverse both polynomials simultaneously, comparing exponents at each step. Best approach is two-pointer merge with Time: O(n+m), Space: O(n+m).

Common Approaches

✓ Brute Force - Nested Scanning

⏱️ Time: O(n×m) Space: O(n+m)

Iterate through each term in the first polynomial. For every term, scan the entire second polynomial to find terms with matching exponents and add their coefficients. Create new nodes for the result polynomial.

Two-Pointer Merge

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

Maintain two pointers, one for each polynomial. Compare exponents at current positions. If equal, add coefficients. If first is greater, take from first polynomial. Otherwise, take from second. Advance pointers accordingly.

Brute Force - Nested Scanning — Algorithm Steps

For each node in first polynomial
Scan entire second polynomial for matching exponent
Add coefficients if match found
Create result nodes and link them

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Term

Pick current term from first polynomial

Scan All

Search entire second polynomial for matching exponent

Add & Repeat

Add coefficients if match found, repeat for next term

Code -

solution.c — C

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

struct ListNode {
    int coeff;
    int exp;
    struct ListNode* next;
};

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

struct ListNode* solution(struct ListNode* poly1, struct ListNode* poly2) {
    if (!poly1) return poly2;
    if (!poly2) return poly1;
    
    struct ListNode* resultHead = createNode(0, 0);
    struct ListNode* current = resultHead;
    
    // Process first polynomial
    struct ListNode* p1 = poly1;
    while (p1) {
        int coeffSum = p1->coeff;
        int exp = p1->exp;
        
        // Find matching exponent in second polynomial
        struct ListNode* p2 = poly2;
        while (p2) {
            if (p2->exp == exp) {
                coeffSum += p2->coeff;
                break;
            }
            p2 = p2->next;
        }
        
        if (coeffSum != 0) {
            current->next = createNode(coeffSum, exp);
            current = current->next;
        }
        p1 = p1->next;
    }
    
    // Process remaining terms from second polynomial
    // This would need additional logic to avoid duplicates
    
    return resultHead->next;
}

int main() {
    // Input parsing would be complex for this problem
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

For each term in first polynomial (n), we scan all terms in second polynomial (m)

✓ Linear Growth

Space Complexity

O(n+m)

Result polynomial can have at most n+m terms

⚡ Linearithmic Space

8.5K Views

Medium Frequency

~25 min Avg. Time

340 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

Polynomial Addition - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Nested Scanning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler