GFG App
Open App
Browser
Continue

# Multiplication of two polynomials using Linked list

Given two polynomials in the form of linked list. The task is to find the multiplication of both polynomials.

Examples:

```Input: Poly1: 3x^2 + 5x^1 + 6, Poly2: 6x^1 + 8
Output: 18x^3 + 54x^2 + 76x^1 + 48
On multiplying each element of 1st polynomial with
elements of 2nd polynomial, we get
18x^3 + 24x^2 + 30x^2 + 40x^1 + 36x^1 + 48
On adding values with same power of x,
18x^3 + 54x^2 + 76x^1 + 48

Input: Poly1: 3x^3 + 6x^1 - 9, Poly2: 9x^3 - 8x^2 + 7x^1 + 2
Output: 27x^6 - 24x^5 + 75x^4 - 123x^3 + 114x^2 - 51x^1 - 18```

Approach:

1. In this approach we will multiply the 2nd polynomial with each term of 1st polynomial.
2. Store the multiplied value in a new linked list.
3. Then we will add the coefficients of elements having the same power in resultant polynomial.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Node structure containing powerer ` `// and coefficient of variable ` `struct` `Node { ` `    ``int` `coeff, power; ` `    ``Node* next; ` `}; ` ` `  `// Function add a new node at the end of list ` `Node* addnode(Node* start, ``int` `coeff, ``int` `power) ` `{ ` `    ``// Create a new node ` `    ``Node* newnode = ``new` `Node; ` `    ``newnode->coeff = coeff; ` `    ``newnode->power = power; ` `    ``newnode->next = NULL; ` ` `  `    ``// If linked list is empty ` `    ``if` `(start == NULL) ` `        ``return` `newnode; ` ` `  `    ``// If linked list has nodes ` `    ``Node* ptr = start; ` `    ``while` `(ptr->next != NULL) ` `        ``ptr = ptr->next; ` `    ``ptr->next = newnode; ` ` `  `    ``return` `start; ` `} ` ` `  `// Function To Display The Linked list ` `void` `printList(``struct` `Node* ptr) ` `{ ` `    ``while` `(ptr->next != NULL) { ` `        ``cout << ptr->coeff << ``"x^"` `<< ptr->power ; ` `       ``if``( ptr->next!=NULL && ptr->next->coeff >=0) ` `          ``cout << ``"+"``; ` ` `  `        ``ptr = ptr->next; ` `    ``} ` `    ``cout << ptr->coeff << ``"\n"``; ` `} ` ` `  `// Function to add coefficients of ` `// two elements having same powerer ` `void` `removeDuplicates(Node* start) ` `{ ` `    ``Node *ptr1, *ptr2, *dup; ` `    ``ptr1 = start; ` ` `  `    ``/* Pick elements one by one */` `    ``while` `(ptr1 != NULL && ptr1->next != NULL) { ` `        ``ptr2 = ptr1; ` ` `  `        ``// Compare the picked element ` `        ``// with rest of the elements ` `        ``while` `(ptr2->next != NULL) { ` ` `  `            ``// If powerer of two elements are same ` `            ``if` `(ptr1->power == ptr2->next->power) { ` ` `  `                ``// Add their coefficients and put it in 1st element ` `                ``ptr1->coeff = ptr1->coeff + ptr2->next->coeff; ` `                ``dup = ptr2->next; ` `                ``ptr2->next = ptr2->next->next; ` ` `  `                ``// remove the 2nd element ` `                ``delete` `(dup); ` `            ``} ` `            ``else` `                ``ptr2 = ptr2->next; ` `        ``} ` `        ``ptr1 = ptr1->next; ` `    ``} ` `} ` ` `  `// Function two Multiply two polynomial Numbers ` `Node* multiply(Node* poly1, Node* poly2, ` `               ``Node* poly3) ` `{ ` ` `  `    ``// Create two pointer and store the ` `    ``// address of 1st and 2nd polynomials ` `    ``Node *ptr1, *ptr2; ` `    ``ptr1 = poly1; ` `    ``ptr2 = poly2; ` `    ``while` `(ptr1 != NULL) { ` `        ``while` `(ptr2 != NULL) { ` `            ``int` `coeff, power; ` ` `  `            ``// Multiply the coefficient of both ` `            ``// polynomials and store it in coeff ` `            ``coeff = ptr1->coeff * ptr2->coeff; ` ` `  `            ``// Add the powerer of both polynomials ` `            ``// and store it in power ` `            ``power = ptr1->power + ptr2->power; ` ` `  `            ``// Invoke addnode function to create ` `            ``// a newnode by passing three parameters ` `            ``poly3 = addnode(poly3, coeff, power); ` ` `  `            ``// move the pointer of 2nd polynomial ` `            ``// two get its next term ` `            ``ptr2 = ptr2->next; ` `        ``} ` ` `  `        ``// Move the 2nd pointer to the ` `        ``// starting point of 2nd polynomial ` `        ``ptr2 = poly2; ` ` `  `        ``// move the pointer of 1st polynomial ` `        ``ptr1 = ptr1->next; ` `    ``} ` ` `  `    ``// this function will be invoke to add ` `    ``// the coefficient of the elements ` `    ``// having same powerer from the resultant linked list ` `    ``removeDuplicates(poly3); ` `    ``return` `poly3; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` ` `  `    ``Node *poly1 = NULL, *poly2 = NULL, *poly3 = NULL; ` ` `  `    ``// Creation of 1st Polynomial: 3x^2 + 5x^1 + 6 ` `    ``poly1 = addnode(poly1, 3, 3); ` `    ``poly1 = addnode(poly1, 6, 1); ` `    ``poly1 = addnode(poly1, -9, 0); ` ` `  `    ``// Creation of 2nd polynomial: 6x^1 + 8 ` `    ``poly2 = addnode(poly2, 9, 3); ` `    ``poly2 = addnode(poly2, -8, 2); ` `    ``poly2 = addnode(poly2, 7, 1); ` `    ``poly2 = addnode(poly2, 2, 0); ` ` `  `    ``// Displaying 1st polynomial ` `    ``cout << ``"1st Polynomial:- "``; ` `    ``printList(poly1); ` ` `  `    ``// Displaying 2nd polynomial ` `    ``cout << ``"2nd Polynomial:- "``; ` `    ``printList(poly2); ` ` `  `    ``// calling multiply function ` `    ``poly3 = multiply(poly1, poly2, poly3); ` ` `  `    ``// Displaying Resultant Polynomial ` `    ``cout << ``"Resultant Polynomial:- "``; ` `    ``printList(poly3); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of above approach  ` `import` `java.util.*; ` `class` `GFG ` `{ ` ` `  `// Node structure containing powerer  ` `// and coefficient of variable  ` `static` `class` `Node {  ` `    ``int` `coeff, power;  ` `    ``Node next;  ` `};  ` ` `  `// Function add a new node at the end of list  ` `static` `Node addnode(Node start, ``int` `coeff, ``int` `power)  ` `{  ` `    ``// Create a new node  ` `    ``Node newnode = ``new` `Node();  ` `    ``newnode.coeff = coeff;  ` `    ``newnode.power = power;  ` `    ``newnode.next = ``null``;  ` ` `  `    ``// If linked list is empty  ` `    ``if` `(start == ``null``)  ` `        ``return` `newnode;  ` ` `  `    ``// If linked list has nodes  ` `    ``Node ptr = start;  ` `    ``while` `(ptr.next != ``null``)  ` `        ``ptr = ptr.next;  ` `    ``ptr.next = newnode;  ` ` `  `    ``return` `start;  ` `}  ` ` `  `// Function To Display The Linked list  ` `static` `void` `printList( Node ptr)  ` `{  ` `    ``while` `(ptr.next != ``null``) {  ` `        ``System.out.print( ptr.coeff + ``"x^"` `+ ptr.power + ``" + "``);  ` ` `  `        ``ptr = ptr.next;  ` `    ``}  ` `    ``System.out.print( ptr.coeff  +``"\n"``);  ` `}  ` ` `  `// Function to add coefficients of  ` `// two elements having same powerer  ` `static` `void` `removeDuplicates(Node start)  ` `{  ` `    ``Node ptr1, ptr2, dup;  ` `    ``ptr1 = start;  ` ` `  `    ``/* Pick elements one by one */` `    ``while` `(ptr1 != ``null` `&& ptr1.next != ``null``) {  ` `        ``ptr2 = ptr1;  ` ` `  `        ``// Compare the picked element  ` `        ``// with rest of the elements  ` `        ``while` `(ptr2.next != ``null``) {  ` ` `  `            ``// If powerer of two elements are same  ` `            ``if` `(ptr1.power == ptr2.next.power) {  ` ` `  `                ``// Add their coefficients and put it in 1st element  ` `                ``ptr1.coeff = ptr1.coeff + ptr2.next.coeff;  ` `                ``dup = ptr2.next;  ` `                ``ptr2.next = ptr2.next.next;  ` ` `  `            ``}  ` `            ``else` `                ``ptr2 = ptr2.next;  ` `        ``}  ` `        ``ptr1 = ptr1.next;  ` `    ``}  ` `}  ` ` `  `// Function two Multiply two polynomial Numbers  ` `static` `Node multiply(Node poly1, Node poly2,  ` `            ``Node poly3)  ` `{  ` ` `  `    ``// Create two pointer and store the  ` `    ``// address of 1st and 2nd polynomials  ` `    ``Node ptr1, ptr2;  ` `    ``ptr1 = poly1;  ` `    ``ptr2 = poly2;  ` `    ``while` `(ptr1 != ``null``) {  ` `        ``while` `(ptr2 != ``null``) {  ` `            ``int` `coeff, power;  ` ` `  `            ``// Multiply the coefficient of both  ` `            ``// polynomials and store it in coeff  ` `            ``coeff = ptr1.coeff * ptr2.coeff;  ` ` `  `            ``// Add the powerer of both polynomials  ` `            ``// and store it in power  ` `            ``power = ptr1.power + ptr2.power;  ` ` `  `            ``// Invoke addnode function to create  ` `            ``// a newnode by passing three parameters  ` `            ``poly3 = addnode(poly3, coeff, power);  ` ` `  `            ``// move the pointer of 2nd polynomial  ` `            ``// two get its next term  ` `            ``ptr2 = ptr2.next;  ` `        ``}  ` ` `  `        ``// Move the 2nd pointer to the  ` `        ``// starting point of 2nd polynomial  ` `        ``ptr2 = poly2;  ` ` `  `        ``// move the pointer of 1st polynomial  ` `        ``ptr1 = ptr1.next;  ` `    ``}  ` ` `  `    ``// this function will be invoke to add  ` `    ``// the coefficient of the elements  ` `    ``// having same powerer from the resultant linked list  ` `    ``removeDuplicates(poly3);  ` `    ``return` `poly3;  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `main(String args[])  ` `{  ` ` `  `    ``Node poly1 = ``null``, poly2 = ``null``, poly3 = ``null``;  ` ` `  `    ``// Creation of 1st Polynomial: 3x^2 + 5x^1 + 6  ` `    ``poly1 = addnode(poly1, ``3``, ``2``);  ` `    ``poly1 = addnode(poly1, ``5``, ``1``);  ` `    ``poly1 = addnode(poly1, ``6``, ``0``);  ` ` `  `    ``// Creation of 2nd polynomial: 6x^1 + 8  ` `    ``poly2 = addnode(poly2, ``6``, ``1``);  ` `    ``poly2 = addnode(poly2, ``8``, ``0``);  ` ` `  `    ``// Displaying 1st polynomial  ` `    ``System.out.print(``"1st Polynomial:- "``);  ` `    ``printList(poly1);  ` ` `  `    ``// Displaying 2nd polynomial  ` `    ``System.out.print(``"2nd Polynomial:- "``);  ` `    ``printList(poly2);  ` ` `  `    ``// calling multiply function  ` `    ``poly3 = multiply(poly1, poly2, poly3);  ` ` `  `    ``// Displaying Resultant Polynomial  ` `    ``System.out.print( ``"Resultant Polynomial:- "``);  ` `    ``printList(poly3);  ` ` `  `}  ` ` `  ` `  `} ` `// This code is contributed by Arnab Kundu `

## Python3

 `# Python3 implementation of the above approach ` `  `  `# Node structure containing powerer ` `# and coefficient of variable ` `class` `Node:    ` `    ``def` `__init__(``self``):        ` `        ``self``.coeff ``=` `None` `        ``self``.power ``=` `None` `        ``self``.``next` `=` `None` `  `  `# Function add a new node at the end of list ` `def` `addnode(start, coeff, power): ` ` `  `    ``# Create a new node ` `    ``newnode ``=` `Node(); ` `    ``newnode.coeff ``=` `coeff; ` `    ``newnode.power ``=` `power; ` `    ``newnode.``next` `=` `None``; ` `  `  `    ``# If linked list is empty ` `    ``if` `(start ``=``=` `None``): ` `        ``return` `newnode; ` `  `  `    ``# If linked list has nodes ` `    ``ptr ``=` `start; ` `    ``while` `(ptr.``next` `!``=` `None``): ` `        ``ptr ``=` `ptr.``next``; ` `    ``ptr.``next` `=` `newnode;  ` `    ``return` `start; ` `  `  `# Function To Display The Linked list ` `def` `printList(ptr): ` ` `  `    ``while` `(ptr.``next` `!``=` `None``): ` `        ``print``(``str``(ptr.coeff) ``+` `'x^'` `+` `str``(ptr.power), end ``=` `'') ` `        ``if``( ptr.``next` `!``=` `None` `and` `ptr.``next``.coeff >``=` `0``): ` `            ``print``(``'+'``, end ``=` `'')  ` `        ``ptr ``=` `ptr.``next` `    ``print``(ptr.coeff) ` `      `  `# Function to add coefficients of ` `# two elements having same powerer ` `def` `removeDuplicates(start): ` `    ``ptr2 ``=` `None` `    ``dup ``=` `None` `    ``ptr1 ``=` `start; ` `  `  `    ``# Pick elements one by one  ` `    ``while` `(ptr1 !``=` `None` `and` `ptr1.``next` `!``=` `None``): ` `        ``ptr2 ``=` `ptr1; ` `  `  `        ``# Compare the picked element ` `        ``# with rest of the elements ` `        ``while` `(ptr2.``next` `!``=` `None``): ` `  `  `            ``# If powerer of two elements are same ` `            ``if` `(ptr1.power ``=``=` `ptr2.``next``.power): ` `  `  `                ``# Add their coefficients and put it in 1st element ` `                ``ptr1.coeff ``=` `ptr1.coeff ``+` `ptr2.``next``.coeff; ` `                ``dup ``=` `ptr2.``next``; ` `                ``ptr2.``next` `=` `ptr2.``next``.``next``; ` `             `  `            ``else``: ` `                ``ptr2 ``=` `ptr2.``next``; ` `         `  `        ``ptr1 ``=` `ptr1.``next``; ` `     `  `# Function two Multiply two polynomial Numbers ` `def` `multiply(poly1, Npoly2, poly3): ` `  `  `    ``# Create two pointer and store the ` `    ``# address of 1st and 2nd polynomials ` `    ``ptr1 ``=` `poly1; ` `    ``ptr2 ``=` `poly2; ` `     `  `    ``while` `(ptr1 !``=` `None``): ` `        ``while` `(ptr2 !``=` `None``): ` `  `  `            ``# Multiply the coefficient of both ` `            ``# polynomials and store it in coeff ` `            ``coeff ``=` `ptr1.coeff ``*` `ptr2.coeff; ` `  `  `            ``# Add the powerer of both polynomials ` `            ``# and store it in power ` `            ``power ``=` `ptr1.power ``+` `ptr2.power; ` `  `  `            ``# Invoke addnode function to create ` `            ``# a newnode by passing three parameters ` `            ``poly3 ``=` `addnode(poly3, coeff, power); ` `  `  `            ``# move the pointer of 2nd polynomial ` `            ``# two get its next term ` `            ``ptr2 ``=` `ptr2.``next``; ` `          `  `        ``# Move the 2nd pointer to the ` `        ``# starting point of 2nd polynomial ` `        ``ptr2 ``=` `poly2; ` `  `  `        ``# move the pointer of 1st polynomial ` `        ``ptr1 ``=` `ptr1.``next``; ` `      `  `    ``# this function will be invoke to add ` `    ``# the coefficient of the elements ` `    ``# having same powerer from the resultant linked list ` `    ``removeDuplicates(poly3); ` `    ``return` `poly3; ` `  `  `# Driver Code ` `if` `__name__``=``=``'__main__'``:  ` `    ``poly1 ``=` `None` `    ``poly2 ``=` `None` `    ``poly3 ``=` `None``; ` `  `  `    ``# Creation of 1st Polynomial: 3x^2 + 5x^1 + 6 ` `    ``poly1 ``=` `addnode(poly1, ``3``, ``3``); ` `    ``poly1 ``=` `addnode(poly1, ``6``, ``1``); ` `    ``poly1 ``=` `addnode(poly1, ``-``9``, ``0``); ` `  `  `    ``# Creation of 2nd polynomial: 6x^1 + 8 ` `    ``poly2 ``=` `addnode(poly2, ``9``, ``3``); ` `    ``poly2 ``=` `addnode(poly2, ``-``8``, ``2``); ` `    ``poly2 ``=` `addnode(poly2, ``7``, ``1``); ` `    ``poly2 ``=` `addnode(poly2, ``2``, ``0``); ` `  `  `    ``# Displaying 1st polynomial ` `    ``print``(``"1st Polynomial:- "``, end ``=` `''); ` `    ``printList(poly1); ` `  `  `    ``# Displaying 2nd polynomial ` `    ``print``(``"2nd Polynomial:- "``, end ``=` `''); ` `    ``printList(poly2); ` `  `  `    ``# calling multiply function ` `    ``poly3 ``=` `multiply(poly1, poly2, poly3); ` `  `  `    ``# Displaying Resultant Polynomial ` `    ``print``(``"Resultant Polynomial:- "``, end ``=` `''); ` `    ``printList(poly3); ` `  `  `# This code is contributed by rutvik_56`

## C#

 `// C# implementation of above approach  ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// Node structure containing powerer  ` `// and coefficient of variable  ` `public` `class` `Node  ` `{  ` `    ``public` `int` `coeff, power;  ` `    ``public` `Node next;  ` `};  ` ` `  `// Function add a new node at the end of list  ` `static` `Node addnode(Node start, ``int` `coeff, ``int` `power)  ` `{  ` `    ``// Create a new node  ` `    ``Node newnode = ``new` `Node();  ` `    ``newnode.coeff = coeff;  ` `    ``newnode.power = power;  ` `    ``newnode.next = ``null``;  ` ` `  `    ``// If linked list is empty  ` `    ``if` `(start == ``null``)  ` `        ``return` `newnode;  ` ` `  `    ``// If linked list has nodes  ` `    ``Node ptr = start;  ` `    ``while` `(ptr.next != ``null``)  ` `        ``ptr = ptr.next;  ` `    ``ptr.next = newnode;  ` ` `  `    ``return` `start;  ` `}  ` ` `  `// Function To Display The Linked list  ` `static` `void` `printList( Node ptr)  ` `{  ` `    ``while` `(ptr.next != ``null``)  ` `    ``{  ` `        ``Console.Write( ptr.coeff + ``"x^"` `+ ptr.power + ``" + "``);  ` ` `  `        ``ptr = ptr.next;  ` `    ``}  ` `    ``Console.Write( ptr.coeff +``"\n"``);  ` `}  ` ` `  `// Function to add coefficients of  ` `// two elements having same powerer  ` `static` `void` `removeDuplicates(Node start)  ` `{  ` `    ``Node ptr1, ptr2, dup;  ` `    ``ptr1 = start;  ` ` `  `    ``/* Pick elements one by one */` `    ``while` `(ptr1 != ``null` `&& ptr1.next != ``null``) ` `    ``{  ` `        ``ptr2 = ptr1;  ` ` `  `        ``// Compare the picked element  ` `        ``// with rest of the elements  ` `        ``while` `(ptr2.next != ``null``)  ` `        ``{  ` ` `  `            ``// If powerer of two elements are same  ` `            ``if` `(ptr1.power == ptr2.next.power)  ` `            ``{  ` ` `  `                ``// Add their coefficients and put it in 1st element  ` `                ``ptr1.coeff = ptr1.coeff + ptr2.next.coeff;  ` `                ``dup = ptr2.next;  ` `                ``ptr2.next = ptr2.next.next;  ` ` `  `            ``}  ` `            ``else` `                ``ptr2 = ptr2.next;  ` `        ``}  ` `        ``ptr1 = ptr1.next;  ` `    ``}  ` `}  ` ` `  `// Function two Multiply two polynomial Numbers  ` `static` `Node multiply(Node poly1, Node poly2,  ` `            ``Node poly3)  ` `{  ` ` `  `    ``// Create two pointer and store the  ` `    ``// address of 1st and 2nd polynomials  ` `    ``Node ptr1, ptr2;  ` `    ``ptr1 = poly1;  ` `    ``ptr2 = poly2;  ` `    ``while` `(ptr1 != ``null``) ` `    ``{  ` `        ``while` `(ptr2 != ``null``)  ` `        ``{  ` `            ``int` `coeff, power;  ` ` `  `            ``// Multiply the coefficient of both  ` `            ``// polynomials and store it in coeff  ` `            ``coeff = ptr1.coeff * ptr2.coeff;  ` ` `  `            ``// Add the powerer of both polynomials  ` `            ``// and store it in power  ` `            ``power = ptr1.power + ptr2.power;  ` ` `  `            ``// Invoke addnode function to create  ` `            ``// a newnode by passing three parameters  ` `            ``poly3 = addnode(poly3, coeff, power);  ` ` `  `            ``// move the pointer of 2nd polynomial  ` `            ``// two get its next term  ` `            ``ptr2 = ptr2.next;  ` `        ``}  ` ` `  `        ``// Move the 2nd pointer to the  ` `        ``// starting point of 2nd polynomial  ` `        ``ptr2 = poly2;  ` ` `  `        ``// move the pointer of 1st polynomial  ` `        ``ptr1 = ptr1.next;  ` `    ``}  ` ` `  `    ``// this function will be invoke to add  ` `    ``// the coefficient of the elements  ` `    ``// having same powerer from the resultant linked list  ` `    ``removeDuplicates(poly3);  ` `    ``return` `poly3;  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `Main(String []args)  ` `{  ` ` `  `    ``Node poly1 = ``null``, poly2 = ``null``, poly3 = ``null``;  ` ` `  `    ``// Creation of 1st Polynomial: 3x^2 + 5x^1 + 6  ` `    ``poly1 = addnode(poly1, 3, 2);  ` `    ``poly1 = addnode(poly1, 5, 1);  ` `    ``poly1 = addnode(poly1, 6, 0);  ` ` `  `    ``// Creation of 2nd polynomial: 6x^1 + 8  ` `    ``poly2 = addnode(poly2, 6, 1);  ` `    ``poly2 = addnode(poly2, 8, 0);  ` ` `  `    ``// Displaying 1st polynomial  ` `    ``Console.Write(``"1st Polynomial:- "``);  ` `    ``printList(poly1);  ` ` `  `    ``// Displaying 2nd polynomial  ` `    ``Console.Write(``"2nd Polynomial:- "``);  ` `    ``printList(poly2);  ` ` `  `    ``// calling multiply function  ` `    ``poly3 = multiply(poly1, poly2, poly3);  ` ` `  `    ``// Displaying Resultant Polynomial  ` `    ``Console.Write( ``"Resultant Polynomial:- "``);  ` `    ``printList(poly3);  ` `}  ` `} ` ` `  `// This code has been contributed by 29AjayKumar `

## Javascript

 ``

Output

```1st Polynomial:- 3x^3+6x^1-9
2nd Polynomial:- 9x^3-8x^2+7x^1+2
Resultant Polynomial:- 27x^6-24x^5+75x^4-123x^3+114x^2-51x^1-18```

Time Complexity: O(m*n) where m and n are number of nodes in first and second lists respectively.
Auxiliary Space: O(m+n)

My Personal Notes arrow_drop_up