Related Articles
• Last Updated : 23 Nov, 2020

Given two polynomials P1 and P2 in the form of a singly linked list respectively, the task is to print the quotient and remainder expressions in the form of a singly linked list, obtained by dividing the polynomials P1 by P2.
Note: Assume the polynomial is expressed as the higher power of x to the lower power of x(i.e., 0).

Examples:

Input: P1 = 5 -> 4 -> 2, P2 = 5 -> 5
Output:
Quotient = 1 -> 0.2
Remainder = 3

Input: P1 = 3 -> 5 -> 2, P2 = 2 -> 1
Output:
Quotient = 1.5 -> 1.75
Remainder = 0.25

Approach: Follow the steps below to solve the problem:

• Create two singly linked lists, quotient, and the remainder, where each node will consist of the coefficient of power of x, and a pointer to the next node.
• While the degree of the remainder is less than the degree of the divisor do the following:
• Subtract the power of the leading term of the dividend by that of the divisor and store in power.
• Divide the coefficient of the leading term of the dividend by the divisor and store in the variable coefficient.
• Create a new node N from the terms formed in step 1 and step 2 and insert N in the quotient list.
• Multiply N with the divisor and subtract the dividend from the obtained result.
• After the above steps, print the quotient and the remainder list.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Node structure containing power and ` `// coefficient of variable ` `struct` `Node { ` `    ``float` `coeff; ` `    ``int` `pow``; ` `    ``struct` `Node* next; ` `}; ` ` `  `// Function to create new node ` `void` `create_node(``float` `x, ``int` `y, ` `                 ``struct` `Node** temp) ` `{ ` `    ``struct` `Node *r, *z; ` `    ``z = *temp; ` ` `  `    ``// If temp is NULL ` `    ``if` `(z == NULL) { ` ` `  `        ``r = (``struct` `Node*)``malloc``( ` `            ``sizeof``(``struct` `Node)); ` ` `  `        ``// Update coefficient and ` `        ``// power in the LL z ` `        ``r->coeff = x; ` `        ``r->``pow` `= y; ` `        ``*temp = r; ` `        ``r->next = (``struct` `Node*)``malloc``( ` `            ``sizeof``(``struct` `Node)); ` `        ``r = r->next; ` `        ``r->next = NULL; ` `    ``} ` ` `  `    ``// Otherwise ` `    ``else` `{ ` `        ``r->coeff = x; ` `        ``r->``pow` `= y; ` `        ``r->next = (``struct` `Node*)``malloc``( ` `            ``sizeof``(``struct` `Node)); ` `        ``r = r->next; ` `        ``r->next = NULL; ` `    ``} ` `} ` ` `  `// Function to create a LL that stores ` `// the value of the quotient while ` `// performing polynomial division ` `void` `store_quotient(``float` `mul_c, ``int` `diff, ` `                    ``struct` `Node* quo) ` `{ ` `    ``// Till quo is non-empty ` `    ``while` `(quo->next != NULL) { ` `        ``quo = quo->next; ` `    ``} ` ` `  `    ``// Update powers and coefficient ` `    ``quo->``pow` `= diff; ` `    ``quo->coeff = mul_c; ` `    ``quo->next = (``struct` `Node*)``malloc``( ` `        ``sizeof``(``struct` `Node)); ` `    ``quo = quo->next; ` `    ``quo->next = NULL; ` `} ` ` `  `// Function to create a new polynomial ` `// whenever subtraction is performed ` `// in polynomial division ` `void` `formNewPoly(``int` `diff, ``float` `mul_c, ` `                 ``struct` `Node* poly) ` `{ ` `    ``// Till poly is not empty ` `    ``while` `(poly->next != NULL) { ` `        ``poly->``pow` `+= diff; ` `        ``poly->coeff *= mul_c; ` `        ``poly = poly->next; ` `    ``} ` `} ` ` `  `// Function to copy one polynomial ` `// into another linkedlist ` `void` `copyList(``struct` `Node* r, ` `              ``struct` `Node** copy) ` `{ ` `    ``// Copy the values of r in the ` `    ``// polynomial copy ` `    ``while` `(r != NULL) { ` ` `  `        ``struct` `Node* z ` `            ``= (``struct` `Node*)``malloc``( ` `                ``sizeof``(``struct` `Node)); ` ` `  `        ``// Store coeffcient and power ` `        ``z->coeff = r->coeff; ` `        ``z->``pow` `= r->``pow``; ` `        ``z->next = NULL; ` ` `  `        ``struct` `Node* dis = *copy; ` `        ``if` `(dis == NULL) { ` `            ``*copy = z; ` `        ``} ` `        ``else` `{ ` `            ``while` `(dis->next != NULL) { ` `                ``dis = dis->next; ` `            ``} ` `            ``dis->next = z; ` `        ``} ` `        ``r = r->next; ` `    ``} ` `} ` ` `  `// Function to subtract two polynomial ` `void` `polySub(``struct` `Node* poly1, ` `             ``struct` `Node* poly2, ` `             ``struct` `Node* poly) ` `{ ` ` `  `    ``// Compute until poly1 and poly2 is empty ` `    ``while` `(poly1->next && poly2->next) { ` ` `  `        ``// If power of 1st polynomial ` `        ``// > 2nd, then store 1st as ` `        ``// it is and move its pointer ` `        ``if` `(poly1->``pow` `> poly2->``pow``) { ` ` `  `            ``poly->``pow` `= poly1->``pow``; ` `            ``poly->coeff = poly1->coeff; ` `            ``poly1 = poly1->next; ` `            ``poly->next ` `                ``= (``struct` `Node*)``malloc``( ` `                    ``sizeof``(``struct` `Node)); ` `            ``poly = poly->next; ` `            ``poly->next = NULL; ` `        ``} ` ` `  `        ``// If power of 2nd polynomial > ` `        ``// 1st then store 2nd as it is ` `        ``// and move its pointer ` `        ``else` `if` `(poly1->``pow` `< poly2->``pow``) { ` ` `  `            ``poly->``pow` `= poly2->``pow``; ` `            ``poly->coeff = -1 * poly2->coeff; ` `            ``poly2 = poly2->next; ` `            ``poly->next ` `                ``= (``struct` `Node*)``malloc``( ` `                    ``sizeof``(``struct` `Node)); ` `            ``poly = poly->next; ` `            ``poly->next = NULL; ` `        ``} ` ` `  `        ``// If power of both polynomial ` `        ``// is same then subtract their ` `        ``// coefficients ` `        ``else` `{ ` ` `  `            ``if` `((poly1->coeff ` `                 ``- poly2->coeff) ` `                ``!= 0) { ` ` `  `                ``poly->``pow` `= poly1->``pow``; ` `                ``poly->coeff = (poly1->coeff ` `                               ``- poly2->coeff); ` ` `  `                ``poly->next = (``struct` `Node*)``malloc``( ` `                    ``sizeof``(``struct` `Node)); ` `                ``poly = poly->next; ` `                ``poly->next = NULL; ` `            ``} ` ` `  `            ``// Update the pointers ` `            ``// poly1 and poly2 ` `            ``poly1 = poly1->next; ` `            ``poly2 = poly2->next; ` `        ``} ` `    ``} ` ` `  `    ``// Add the remaining value of polynomials ` `    ``while` `(poly1->next || poly2->next) { ` ` `  `        ``// If poly1 exists ` `        ``if` `(poly1->next) { ` `            ``poly->``pow` `= poly1->``pow``; ` `            ``poly->coeff = poly1->coeff; ` `            ``poly1 = poly1->next; ` `        ``} ` ` `  `        ``// If poly2 exists ` `        ``if` `(poly2->next) { ` `            ``poly->``pow` `= poly2->``pow``; ` `            ``poly->coeff = -1 * poly2->coeff; ` `            ``poly2 = poly2->next; ` `        ``} ` ` `  `        ``// Add the new node to poly ` `        ``poly->next ` `            ``= (``struct` `Node*)``malloc``( ` `                ``sizeof``(``struct` `Node)); ` `        ``poly = poly->next; ` `        ``poly->next = NULL; ` `    ``} ` `} ` ` `  `// Function to display linked list ` `void` `show(``struct` `Node* node) ` `{ ` `    ``int` `count = 0; ` `    ``while` `(node->next != NULL ` `           ``&& node->coeff != 0) { ` ` `  `        ``// If count is non-zero, then ` `        ``// print the postitive value ` `        ``if` `(count == 0) ` `            ``cout << node->coeff; ` ` `  `        ``// Otherwise ` `        ``else` `            ``cout << ``abs``(node->coeff); ` `        ``count++; ` ` `  `        ``// Print polynomial power ` `        ``if` `(node->``pow` `!= 0) ` `            ``cout << ``"x^"` `<< node->``pow``; ` `        ``node = node->next; ` ` `  `        ``if` `(node->next != NULL) ` ` `  `            ``// If coeff of next term ` `            ``// > 0 then next sign will ` `            ``// be positive else negative ` `            ``if` `(node->coeff > 0) ` `                ``cout << ``" + "``; ` `            ``else` `                ``cout << ``" - "``; ` `    ``} ` ` `  `    ``cout << ``"\n"``; ` `} ` ` `  `// Function to divide two polynomials ` `void` `divide_poly(``struct` `Node* poly1, ` `                 ``struct` `Node* poly2) ` `{ ` `    ``// Initialize Remainder and Quotient ` `    ``struct` `Node *rem = NULL, *quo = NULL; ` ` `  `    ``quo = (``struct` `Node*)``malloc``( ` `        ``sizeof``(``struct` `Node)); ` `    ``quo->next = NULL; ` ` `  `    ``struct` `Node *q = NULL, *r = NULL; ` ` `  `    ``// Copy poly1, i.e., dividend to q ` `    ``copyList(poly1, &q); ` ` `  `    ``// Copy poly, i.e., diivisor to r ` `    ``copyList(poly2, &r); ` ` `  `    ``// Perform polynomial subtraction till ` `    ``// highest power of q > highest power of divisor ` `    ``while` `(q != NULL ` `           ``&& (q->``pow` `>= poly2->``pow``)) { ` ` `  `        ``// difference of power ` `        ``int` `diff = q->``pow` `- poly2->``pow``; ` ` `  `        ``float` `mul_c = (q->coeff ` `                       ``/ poly2->coeff); ` ` `  `        ``// Stores the quotient node ` `        ``store_quotient(mul_c, diff, ` `                       ``quo); ` ` `  `        ``struct` `Node* q2 = NULL; ` ` `  `        ``// Copy one LL in another LL ` `        ``copyList(r, &q2); ` ` `  `        ``// formNewPoly forms next value ` `        ``// of q after performing the ` `        ``// polynomial subtraction ` `        ``formNewPoly(diff, mul_c, q2); ` ` `  `        ``struct` `Node* store = NULL; ` `        ``store = (``struct` `Node*)``malloc``( ` `            ``sizeof``(``struct` `Node)); ` ` `  `        ``// Perform polynomial subtraction ` `        ``polySub(q, q2, store); ` ` `  `        ``// Now change value of q to the ` `        ``// subtracted value i.e., store ` `        ``q = store; ` `        ``free``(q2); ` `    ``} ` ` `  `    ``// Print the quotient ` `    ``cout << ``"Quotient: "``; ` `    ``show(quo); ` ` `  `    ``// Print the remainder ` `    ``cout << ``"Remainder: "``; ` `    ``rem = q; ` `    ``show(rem); ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``struct` `Node* poly1 = NULL; ` `    ``struct` `Node *poly2 = NULL, *poly = NULL; ` ` `  `    ``// Create 1st Polynomial (Dividend): ` `    ``// 5x^2 + 4x^1 + 2 ` `    ``create_node(5.0, 2, &poly1); ` `    ``create_node(4.0, 1, &poly1); ` `    ``create_node(2.0, 0, &poly1); ` ` `  `    ``// Create 2nd Polynomial (Divisor): ` `    ``// 5x^1 + 5 ` `    ``create_node(5.0, 1, &poly2); ` `    ``create_node(5.0, 0, &poly2); ` ` `  `    ``// Function Call ` `    ``divide_poly(poly1, poly2); ` ` `  `    ``return` `0; ` `} `

Output:

```Quotient: 1x^1 - 0.2
Remainder: 3
```

Time Complexity: O(M + N)
Auxiliary Space: O(M + N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :