Related Articles

# Polynomial Division using Linked List

• Last Updated : 14 Sep, 2021

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 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., 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)

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up