Assignment no:7 Exp No:7

Date: Signature:
Problem statement:write a program in c to addd two polymomials using singly linked
list and add these two polynomials

Statement:polynmial is a mathematical expression consisting of variables and constants.

For example :4x^7+12x^2+2

Linked list:It is a linear data structure that consists of nodes where eachh node consists of data storage
part and a pointer to the next node in the linked list.

Polynomial addition uusing linked list:we store each polynomial as a singly linked list where eachh node
stores the exponent and cooefficient in the data part and a referrence to the next node as shown in the
figure below.Their sum is then stored in another list.

Procedure: consider two polynomials where polynomial

2.4x^2+7x

They are stored in a linked list as shown below.

The sum of themi.e. 5x^4+6x^2+10x

Which is stored in the resultant linked list as ahown below.

Input:

1.Read two polynomials.

Output:

1.Displays the sum of two polynomials given

Algo:

Step 1: Start.

Step 2: Define user defined datatype node consisting of int coefficient and exponent and a pointer

next of type node.

Step 3: Defining create function

struct node* create(struct node* head, int co, int exp)

Check if(head == Null)

temp <- GetNode(node)

temp.co <- co

temp.exp <- exp

Set head <- temp

otherwise

Set temp <- head

while(temp.next ≠ Null) do

temp <- temp.next

flag <- GetNode(node)

flag.co <- co

flag.exp <- exp

flag.next <- Null

temp.next <- flag

return head

Step 4: Defining Addition function

struct node* polyAdd(struct node *p1, struct node *p2, struct node *sum)

Set poly1 <- p1

Set poly2 <- p2

Set result <- Null

check if(poly1 ≠ Null AND poly2 == Null)

Set sum <- poly1

Return sum

else if(poly1 == Null AND poly2 ≠ Null)

Set sum <- poly2

Return sum

while(poly1 ≠ Null AND poly2 ≠ Null) do

Check if(sum == Null)

sum <- GetNode(node)

Set result <- sum

Otherwise

result.next <- GetNode(node)

Check if(poly1.exp > poly2.exp)

Set result.co <- poly1.co

Set result.exp <- poly1.exp

Set poly1 <- poly1.next

Check if(poly1.exp < poly2.exp)

Set result.co <- poly2.co

Set result.exp <- poly2.exp

Set poly2 <- poly2.next

Otherwise

Set result.co <- poly1.co + poly2.co

Set result.exp <- poly1.exp

Set poly1 <- poly1.next

Set poly2 <- poly2.next

while(poly1 ≠ Null) do

Set result.next <- GetNode(node)

Set result <- result.next

Set result.co <- poly1.co

Set result.exp <- poly1.exp

Set poly1 <- poly1.next

while(poly2 ≠ Null) do

Set result.next <- GetNode(node)

Set result <- result.next

Set result.co <- poly2.co

Set result.exp <- poly2.exp

Set poly2 <- poly2.next

Set result.next <- Null

Return sum

Step 5: Defining Display function

Set temp <- head

while(temp ≠ Null) do

Display temp.co, temp.exp

Set temp <- temp.next

Step 6: Defining Main function

Set p2 <- Null

Set sum <- Null

Set flag <- 1

while(flag == 1) do

Display “1: Create Polynomial 1”

Display “2: Create Polynomial 2”

Display “3: Perform Addition”

Display “4: Exit”

Read choice

switch(choice)

Case 1:

Display “Enter coefficient for polynomial 1”

Read co

Display “Enter exponent for polynomial 1”

Read exp

Call create(p1, co, exp)

Case 2:

Display “Enter coefficient for polynomial 2”

Read co

Display “Enter exponent for polynomial 2”

Read exp

Call create(p2, co, exp)

Set sum <- call polyAdd(p1, p2, sum)

Call display(sum)

Case 4:

Set flag <- 0

End switch

Step 7: Stop

Program code:
#include <stdio.h>
#include <stdlib.h>
//polynomial node structure
struct node
{
int co, exp;
struct node* next;
};
//create a polynomial
struct node* create(struct node* head, int co, int exp)
{
struct node *temp,
*flag;
//if polynomial empty. make the node the head node
if(head == NULL)
{
temp = (struct node*) malloc (sizeof(struct node));
temp->co = co;
temp->exp = exp;
temp->next = NULL;
head = temp;
}
else
{
//else go to the last node and append
temp = head;
while(temp->next != NULL)
temp = temp->next;
flag = (struct node *)malloc(sizeof(struct node));
flag->co = co; flag->exp = exp;

flag->next = NULL;
temp->next = flag;
}
return head;
}
//add two polynomial
struct node* polyAdd(struct node *p1, struct node *p2, struct node *sum)
{
//copy the two polynomial and initialize variable res to store the sum
struct node *poly1 = p1,
*poly2 = p2,
*res;
//if polynomial 2 is null, set polynomial 1 as the sum
if(poly1 != NULL && poly2 == NULL)
{
sum = poly1;
return sum;
}
//if polynomial 1 is null, set polynomial 2 as the sum
else if(poly1 == NULL && poly2 != NULL)
{
sum = poly2;
return sum;
}
//if both polynomials are non-empty
while(poly1 != NULL && poly2 != NULL)
{
//if the sum is empty, initialize sum with a node structure
//and set res equal to sum
if(sum == NULL)
{
sum = (struct node *)malloc(sizeof(struct node));
res = sum;
}
//add a new node structure at the end of res to store sum
else
{
res->next = (struct node *)malloc(sizeof(struct node));;
res = res->next;
}
//if exponent of current node of polynomial 1 is greater than that of polynomial 2
//add it to the sum
if(poly1->exp > poly2->exp)
res->co = poly1->co;
res->exp = poly1->exp;
poly1 = poly1->next;
}
//if exponent of current node of polynomial 2 is greater than that of polynomial 1
//add it to the sum
else if(poly1->exp < poly2->exp)
{
res->co = poly2->co;
res->exp = poly2->exp;
poly2 = poly2->next;
}
//if exponent of current node of polynomial 1 is equal to that of polynomial 2
//add the sum of their co-efficient to the sum
else if(poly1->exp == poly2->exp)
{
res->co = poly1->co + poly2->co;
res->exp = poly1->exp;
poly1 = poly1->next;
poly2 = poly2->next;
}
}
//if polynomial 1 is non-empty add the remaining nodes to the sum
while(poly1 != NULL)
{
res->next = (struct node *)malloc(sizeof(struct node));;
res = res->next;
res->co = poly1->co;
res->exp = poly1->exp;
poly1 = poly1->next;
}
//if polynomial 2 is non-empty add the remaining nodes to the sum
while(poly2 != NULL)
{
res->next = (struct node *)malloc(sizeof(struct node));;
res = res->next;
res->co = poly2->co;
res->exp = poly2->exp;
poly2 = poly2->next;
}
//set pointer of last node to null
res->next = NULL;
//return the head node of the sum
return sum;
}
//display polynomial
void display(struct node* head)
{
struct node *temp=head;
while(temp != NULL)
{
printf("%d^%d+", temp->co, temp->exp);
temp=temp->next;
}
printf("\n");
}
void main()
{
//to store polynomial 1, polynomial 2 and the sum
struct node *p1 = NULL,
*p2 = NULL,
*sum = NULL;
int ch, co, exp;
int loop = 1;
while(loop) {
printf("1. Add to Polynomial 1\n");
printf("2. Add to Polynomial 1\n");
printf("3. Perform Addition\n");
printf("4. Exit\n");
scanf("%d", &ch);
switch(ch)
{
case 1: printf("Enter co-efficient\n");
scanf("%d", &co);
printf("Enter exponent\n");
scanf("%d", &exp);
p1 = create(p1, co, exp);
break;
case 2: printf("Enter co-efficient\n");
scanf("%d", &co);
printf("Enter exponent\n");
scanf("%d", &exp);
p2 = create(p2, co, exp);
break;
case 3: sum=polyAdd(p1,p2,sum);
printf("\nPolynomial 1\n");
display(p1);
printf("\nPolynomial 2\n");
display(p2);
printf("\nSum:\n");
display(sum);
break;
case 4: loop = 0;
break;
default: printf("Wrong Choice! Re-enter\n");
break;
}
}

Program output:
1. Enter Polynomial 1
2. Enter Polynomial 2
3. Perform Addition
4. Exit
1
Enter co-efficient
5
Enter exponent
4
1. Enter Polynomial 1
2. Enter Polynomial 2
3. Perform Addition
4. Exit
1
Enter co-efficient
2
Enter exponent
2
1. Enter Polynomial 1
2. Enter Polynomial 2
3. Perform Addition
4. Exit
1
Enter co-efficient
3
Enter exponent
1
1. Enter Polynomial 1
2. Enter Polynomial 2
3. Perform Addition
4. Exit
2
Enter co-efficient
4
Enter exponent
2
1. Enter Polynomial 1
2. Enter Polynomial 2
3. Perform Addition
4. Exit
2
Enter co-efficient
7
Enter exponent
1
1. Enter Polynomial 1
2. Enter Polynomial 2
3. Perform Addition
4. Exit
3
Polynomial 1
5 ^ 4 +2 ^ 2 +3 ^ 1 +
Polynomial 2
4 ^ 2 +7 ^ 1 +
Sum:
5 ^ 4 +6 ^ 2 +10 ^ 1 +
1. Enter Polynomial 1
2. Enter Polynomial 2
3. Perform Addition
4. Exit
4

Program discussion:Characteristics of Polynomial Addition Using Linked List 1.

APPLICATION:

Addition of polynomial mathematical expressions.

ADVANTAGE:
1. Since the algorithm uses a linked list, it is dynamic and hence has efficient
memory utilization.

DISADVANTAGE:
1. The pointer in the linked requires extra memory space.
2. Handling of the pointers while storing and adding increases overhead.
TIME COMPLEXITY
Let n be the number of nodes in Polynomial 1’s linked list and m be the number of
nodes in Polynomial 2’s linked
list.
For Polynomial 1, the create() and display function takes O(n) time and for
polynomial 2 it takes O(m) time.
The polyAdd()function iterates over the two polynomials at the same time and
hence, takes O(n + m) time, and comparing
the two polynomials takes constant O(1) time.
Hence, the time complexity of the algorithm is O(n + m).
SPACE COMPLEXITY
The sum of the two polynomials is stored in a separate linked list.
The number of nodes in the resultant sum linked list is s ≥ n + m.
Hence, the space complexity is O(s) = O(n + m)