## Polynomial multiplication using linked list in c

matrix multiplication using linked list in c
polynomial representation using generalized linked list
c program to implement polynomial using arrays
evaluation of polynomial using linked list

Iam working on a program to perform addition,subtraction,multiplication and differentiation operations on a polynomial using linked list in c. The other operations are working fine except multiplication one. here is the code

```#include<stdio.h>
#include<malloc.h>
#include<conio.h>
int coeff;
int pow;
};
{
char ch;
do
{
printf("\n\nenter coeff:");
scanf("%d",&node->coeff);
printf("\nenter power:");
scanf("%d",&node->pow);
node=node->next;
node->next=NULL;
printf("\ncontinue(y/n):");
ch=getch();
}
while(ch=='y' || ch=='Y');
}
{
while(node->next!=NULL)
{

printf("%dx^%d",node->coeff,node->pow);
node=node->next;
if(node->next!=NULL)
printf(" + ");

}
}
{
while(poly1->next &&  poly2->next)
{
if(poly1->pow>poly2->pow)
{
poly->pow=poly1->pow;
poly->coeff=poly1->coeff;
poly1=poly1->next;
}
else if(poly1->pow<poly2->pow)
{
poly->pow=poly2->pow;
poly->coeff=poly2->coeff;
poly2=poly2->next;
}
else
{
poly->pow=poly1->pow;
poly->coeff=poly1->coeff+poly2->coeff;
poly1=poly1->next;
poly2=poly2->next;
}
poly=poly->next;
poly->next=NULL;
}
while(poly1->next || poly2->next)
{
if(poly1->next)
{
poly->pow=poly1->pow;
poly->coeff=poly1->coeff;
poly1=poly1->next;
}
if(poly2->next)
{
poly->pow=poly2->pow;
poly->coeff=poly2->coeff;
poly2=poly2->next;
}
poly=poly->next;
poly->next=NULL;
}
```

}

```void polysub(struct link *poly1,struct link *poly2,struct link *poly)
{
while(poly1->next &&  poly2->next)
{
if(poly1->pow>poly2->pow)
{
poly->pow=poly1->pow;
poly->coeff=poly1->coeff;
poly1=poly1->next;
}
else if(poly1->pow<poly2->pow)
{
poly->pow=poly2->pow;
poly->coeff=poly2->coeff;
poly2=poly2->next;
}
else
{
poly->pow=poly1->pow;
poly->coeff=poly1->coeff-poly2->coeff;
poly1=poly1->next;
poly2=poly2->next;
}
poly=poly->next;
poly->next=NULL;
}
while(poly1->next || poly2->next)
{
if(poly1->next)
{
poly->pow=poly1->pow;
poly->coeff=poly1->coeff;
poly1=poly1->next;
}
if(poly2->next)
{
poly->pow=poly2->pow;
poly->coeff=poly2->coeff;
poly2=poly2->next;
}
poly=poly->next;
poly->next=NULL;
}
```

}

```void polymul(struct link *n1, struct link *n2, struct link *n)
{

while (n1)
{
temp->next=NULL;
n2=n2beg;
while (n2)
{
temp->coeff = n1->coeff * n2->coeff;

temp->pow = n1->pow + n2->pow;

n2 = n2->next;
temp=temp->next;
temp->next=NULL;

}

n1 = n1->next;
free(temp);
}
```

}

```void diff(struct link* p1,struct link* p2)
{

while(p1->next!=NULL)
{
p2->coeff=p1->coeff*p1->pow;
p2->pow=p1->pow-1;
p2->next=NULL;
p2=p2->next;
p2->next=NULL;
p1=p1->next;
}

}
main()
{
int op;
char ch;
do{
printf("\n\nWhat do you want to do?\n1.Addition\n2.Subtraction
\n3.Multiplication\n4.Differentiation\n0.Exit
scanf("%d",&op);
switch(op)
{
case 1:
printf("\n\nenter 1st polynomial:");
create(poly1);
printf("\n\nenter 2nd polynomial:");
create(poly2);
printf("\n1st Polynomial:\t");
show(poly1);
printf("\n2nd Polynomial:\t");
show(poly2);
show(poly);
break;
case 2:
printf("\n\nenter 1st polynomial:\t");
create(poly1);
printf("\n\nenter 2nd polynomial:\t");
create(poly2);
printf("\n\n1st Polynomial:\t");
show(poly1);
printf("\n\n2nd Polynomial:\t");
show(poly2);
polysub(poly1,poly2,poly);
printf("\n\nSubtracted polynomial:\t");
show(poly);
break;
case 3:
printf("\n\nenter 1st polynomial:");
create(poly1);
printf("\n\nenter 2nd polynomial:");
create(poly2);
printf("\n\n1st Polynomial:\t");
show(poly1);
printf("\n\n2nd Polynomial:\t");
show(poly2);
polymul(poly1,poly2,poly);
printf("\n\nMultiplied polynomial:\t");
show(poly);
break;
case 4:
printf("\n\nenter polynomial:");
create(poly1);
printf("\n\nPolynomial:\t");
show(poly1);
diff(poly1,poly2);
printf("\n\nDifferentiated Polynomial:\t");
show(poly2);
break;
}

/* printf("\n Want to continue? Y/N:");
ch=getch();*/
}
while(op);
```

}

`polyadd(temp,n,n)` as used in `polymul()` has trouble coping with using `n` as a source polynomial and as the sum destination polynomial.

Either re-work `polyadd()` to cope with parameters that point to the same polynomial or re-work the call of `polyadd()` in `polymul()` to use distinct polynomials. Suggest the first.

Multiplication of two polynomials using Linked list, polyadd(temp,n,n) as used in polymul() has trouble coping with using n as a source polynomial and as the sum destination polynomial. 1. Iam working on a program to perform addition,subtraction,multiplication and differentiation operations on a polynomial using linked list in c. The other operations are working fine except multiplication one. here is the code. #include<stdio.h> #include<malloc.h> #include<conio.h> struct link { int coeff; int pow; struct link *next; }; struct link *poly1=NULL,*poly2=NULL,*poly=NULL; void create (struct link *node) { char ch; do { printf (" enter coeff:"); scanf

I did not go through your full code, as I found an error in your `create()` function. Note that you have passed `poly1` to the function `create()` as argument.

This not correct as C follows call by value. What happens is only the value of `poly1` (which is still un-initialised) is passed and `*node` stores that value. It's better to pass the address of `poly1` as argument and catch that value in the function using pointer to pointer.

Polynomial multiplication using linked list in c, Implementation: Polynomials are implemented using single linked lists each node having a coefficient and an exponent part. Pointer is set to… Polynomial Multiplication using Linked List in C Posted on February 9, 2015by subarnopal Following simple algebraic rules we perform the Polynomial multiplication of two polynomials standard forms ax^n+bx^n-1+… where we take two polynomials as input from the user one node after another and later perform the multiplication.

```#include<stdio.h>
#include <conio.h>
struct node
{
int c,e;
}*start1=NULL,*start2=NULL,*start3=NULL,*temp1,*temp2,*temp3,*new_node;
int delete_dup(int h)
{
struct node *cr,*prev,*run,*tmp;

prev = start3;

while(cr != NULL){

run = start3;

while(run != cr)
{
if(run->e == cr->e)
{
run->c+=cr->c;
tmp = cr;
remove(tmp);h--;
break;
}

}

if(run == cr){
}
}
return h;

}

void main()
{
int n,m,i,j,k;
puts("Enter the number of terms in first polynomial");
scanf("%d",&n);
for(i=0;i<n;i++)
{
new_node=(struct node*)malloc(sizeof(struct node));
puts("C=");
scanf("%d",&new_node->c);
puts("E=");
scanf("%d",&new_node->e);
start1=new_node;

}
puts("Enter the number of terms in first polynomial");
scanf("%d",&m);
for(i=0;i<m;i++)
{
new_node=(struct node*)malloc(sizeof(struct node));
puts("C=");
scanf("%d",&new_node->c);
puts("E=");
scanf("%d",&new_node->e);
start2=new_node;

}
temp1=start1;
temp2=start2;
i=0; j=0;
while(i<m)
{
j=0; temp1=start1;
while(j<n)
{
new_node=(struct node*)malloc(sizeof(struct node));
new_node->c=temp1->c*temp2->c;
new_node->e=temp1->e+temp2->e;
start3=new_node;
j++;
}
i++;
}
i=0;
k=delete_dup(m*n);
temp3=start3;
while(i<k-1)

{
printf("(%dx^%d)+",temp3->c,temp3->e);
i++;
}
printf("(%dx^%d)",temp3->c,temp3->e);

}
```

Polynomial Multiplication using Linked List in C, Scheme, APL, Lua, Python 2.7, Ruby, Roy, Python, Nodejs, Deno (beta), Go, C++, C, C#, F#, HTML C – Polynomial Multiplication using Singly Linked List. C​  10 thoughts on “ C Program for Addition and Multiplication of Polynomial Using Arrays or Linked List ” Jayasooryan Kv October 12, 2014. Code working! Thanks. Better if code is aligned.

```#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
struct node{
int coef,pow;
struct node *next;
};

struct node* create()
{
int c;
struct node *new_node=NULL;

do{
new_node=(struct node*)malloc(sizeof(struct node));
printf("\nEnter coef :");
scanf("%d",&new_node->coef);
printf("\nEnter power : ");
scanf("%d",&new_node->pow);

{
temp=new_node;
}
else
{
temp->next=new_node;
temp=temp->next;
temp->next=NULL;
}
printf("\nDo you want to continue :");
scanf("%d",&c);
}while(c==1);
}

void print(struct node *p)
{
while(p!=NULL)
{
printf("|%d|%d|->",p->coef,p->pow);
p=p->next;
}
}

struct node* create_new(int p, int q)
{

struct node *nn=(struct node*)malloc(sizeof(struct node));
nn->coef=p;
nn->pow=q;
nn->next=NULL;
return nn;
}
struct node* add(struct node *poly1,struct node *poly2)
{
struct node *temp1=poly1;
while(temp1!=NULL && temp2!=NULL)
{
if(temp1->pow==temp2->pow)
{
temp1=temp1->next;
temp2=temp2->next;
}
else if(temp1->pow<temp2->pow)
{
temp2=temp2->next;
}
else
{
temp1=temp1->next;
}
{
}
else
{
temp=temp->next;
}

}
if(temp1!=NULL)
{
while(temp1!=NULL)
{
temp1=temp1->next;
temp=temp->next;
}
}
else if(temp2!=NULL)
{
while(temp2!=NULL)
{
temp2=temp2->next;
temp=temp->next;
}
}

}

void main()
{
printf("\n");
printf("\n");
printf("\n\nResult : ");
getch();
}
```

C – Polynomial Multiplication using Singly Linked List, polynomial addition using linked list in c,program for polynomial addition using linked list in data structure in c,addition of two polynomials using  Make a polynomial abstract datatype using struct which basically implements a linked list. We write different functions for Creating (ie, adding more nodes to the linked list) a polynomial function, Adding two polynomials and Showing a polynomial expression.

```#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef struct node {
struct node *previous;
int coef;
int pow;
struct node *next;
}poly;
poly *locate(int,poly *);
void display(poly *);
poly *mult(poly *,poly *,poly *);
void display2(poly *);
void main()
{
char ch;
s1=(poly *)malloc(sizeof(poly));
s1->previous=NULL;
s2=(poly *)malloc(sizeof(poly));
s2->previous=NULL;
printf("Enter first polynomial :\n");
do{                                           //Input for polynomial-1
printf("Enter co-efficient : ");
scanf("%d",&s1->coef);
printf("Enter exponent : ");
scanf("%d",&s1->pow);
printf("Do you want to enter more terms(Y/N) : ");
scanf(" %c",&ch);
if(ch=='Y'){
s1->next=(poly*)malloc(sizeof(poly));
s1->next->previous=s1;
s1=s1->next;
}
else {
s1->next=NULL;
break;
}
}while(1);
printf("Enter second polynomial : \n");
do{                                     //input for polynomial-2
printf("Enter co-efficient : ");
scanf("%d",&s2->coef);
printf("Enter exponent : ");
scanf("%d",&s2->pow);
printf("Do you want to enter more terms(Y/N) : ");
scanf(" %c",&ch);
if(ch=='Y'){
s2->next=(poly*)malloc(sizeof(poly));
s2->next->previous=s2;
s2=s2->next;
}
else {
s2->next=NULL;
break;
}
}while(1);
printf("Entered polynomials are : \n");
display(s1);
printf("\n");
display(s2);
s3=NULL;
s4=mult(s1,s2,s3);
printf("Resultant Polynomial after multiplication :\n");
display(s4);
}
void display(poly *a)
{
while(a!=NULL)
{
printf("%dx^%d",a->coef,a->pow);
if(a->previous!=NULL)
printf(" + ");
a=a->previous;
}
}
poly *mult(poly *s1,poly *s2,poly *s3)
{
while(s1->previous!=NULL)
s1=s1->previous;
while(s2->previous!=NULL)
s2=s2->previous;
while(s1)
{
while(s2->previous!=NULL)
s2=s2->previous;
while(1)
{
if(s2->next!=NULL)
{
poly *s4;
if(s3==NULL)
{
s3=(poly *)malloc(sizeof(poly));
s3->pow=s1->pow+s2->pow;
s3->coef=s1->coef*s2->coef;
s3->previous==NULL;
s3->next==NULL;
}
else
{
s4=locate(s1->pow+s2->pow,s3);
if(s4==NULL)
{
s3->next=(poly *)malloc(sizeof(poly));
s3->next->previous=s3;
s3=s3->next;
s3->pow=s1->pow+s2->pow;
s3->coef=s1->coef*s2->coef;
s3->next==NULL;
}
else
{
s4->coef=(s4->coef)+(s1->coef*s2->coef);
}
}
s2=s2->next;
}
else
{
poly *s4;
if(s3==NULL)
{
s3=(poly *)malloc(sizeof(poly));
s3->pow=s1->pow+s2->pow;
s3->coef=s1->coef*s2->coef;
s3->previous==NULL;
s3->next==NULL;
}
else{
s4=locate(s1->pow+s2->pow,s3);
if(s4==NULL)
{
s3->next=(poly *)malloc(sizeof(poly));
s3->next->previous=s3;
s3=s3->next;
s3->pow=s1->pow+s2->pow;
s3->coef=s1->coef*s2->coef;
s3->next==NULL;
}
else
{
s4->coef=s4->coef+s1->coef*s2->coef;
}
}
break;
};
}s1=s1->next;
}return s3;

}
poly *locate(int exp,poly *s3)
{
if(s3==NULL)
{
return NULL;
}
else if(s3->pow==exp)
{
return s3;
}
else{
return locate(exp,s3->previous);
}
}
```

I considered the first term of first polynomial and multiplied with all the terms of second polynomial thereby creating a primary linked list of multiplied polynomial. As next piece of code I considered next term of first polynomial and then multiplied and searched in the multiplied polynomial for the same index and added the result to it, If it is not present I created a new node in the multiplied polynomial. Happy Coding

• (What did "Community" change in this post?) Instead of implementing `polysub()` in addition to `polyadd()`, do a `polyscale()` for scalar multiplication. (In `polyadd()` it is possible to code copy "unpaired" node to result once - from eight times over as presented.)