# Polynomial Division using Linked List

• Last Updated : 18 Jan, 2022

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 coefficient 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 positive 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., divisor 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)

My Personal Notes arrow_drop_up