Displaying polynomials with linked list in C - c

Question

I am trying to write a code creating and displaying polynomials. My first question is: "Did I use linked list correctly?". Second is: "Why can't I display poynomials?" I want them displayed like: If there are 2 monomials, poynomial should be displayed as; -->(1.0 X 0) -->(1.0 X 3)--E First one is coefficient second one is the exponent.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//this will be the structure named node
struct node
{
int exp; //this line represents the exponent/power b for a*x^b
int coeff; //this line represents the coefficient a for a*x^b
struct node *next; //this line represents the pointer which will point to the next node
};
struct node *create_new_nodes(struct node *m);
struct node *insert(struct node *ptr, struct node *k);
void display(char const *tag, struct node *ptr);
struct node *create_new_nodes(struct node *m)
{
int i;
int n;
printf("Enter the number of nodes: ");
scanf("%d", &n);
for (i = 0; i < n; i++)
{
struct node *ptr = malloc(sizeof(struct node));
printf("Enter the coefficient (a for a*x^b): ");
scanf("%d", &ptr->coeff);
printf("Enter the exponent/power (b for a*x^b): ");
scanf("%d", &ptr->exp);
ptr->next = NULL;
}
return m;
}
void display(char const *tag, struct node *ptr)
{
struct node *temp;
temp = ptr;
printf("%s: ", tag);
while (temp != NULL)
{
printf("-->(%d X %d)--E", temp->coeff, temp->exp);
temp = temp->next;
}
putchar('\n');
}
int main(void)
{
struct node *p1 = NULL, *p2 = NULL;
p1 = create_new_nodes(p1);
p2 = create_new_nodes(p2);
display("p1", p1);
display("p2", p2);
return 0;
}
My output for this code:
Enter the number of nodes: 2
Enter the coefficient (a for a*x^b): 1
Enter the exponent/power (b for a*x^b): 2
Enter the coefficient (a for a*x^b): 2
Enter the exponent/power (b for a*x^b): 3
Enter the number of nodes: 2
Enter the coefficient (a for a*x^b): 3
Enter the exponent/power (b for a*x^b): 4
Enter the coefficient (a for a*x^b): 6
Enter the exponent/power (b for a*x^b): 5
p1:
p2:
As you can see p1 and p2 are not displayed.
I have to mention that I took help from internet while writing some parts of this code. So, there are parts that I didn't understand. If possible, I would like to be clarified for those too.
void display(char const *tag, struct node *ptr)
{
struct node *temp;
const char *pad;
temp = ptr;
printf("%s: ", tag);
while (temp != NULL)
{
printf("-->(%d X %d)--E", temp->coeff, temp->exp);
temp = temp->next;
pad = " + ";
}
putchar('\n');
}
In this part of code, I didn't get why I use temp and tag function.

Answer 1

Let's get you sorted out. Rather than a full general linked-list implementation, you simply need the create, display, and delete functions. Since your lists are just links of structs with exp and coeff, you can simply build a new list each time you call your create function. You do NOT need to provide a parameter to your create function, just declare your list pointer local to the function and then return a pointer to the first node in the allocated list when done.
As noted in the comment, you are headed for a lot of grief unless you check the return for every input function used (and not mentioned, but equally important, check the return of EVERY allocation)
You were not terribly far off where you were headed with your create function, you just never linked the nodes together in your list. You do want to initialize the next pointer NULL following allocation, but you also have to set any existing end node in your list next pointer to point to the new node. That is how you create the "link" in the "linked-list".
Let's take your create function, (I've renamed it create_poly_list()) and essentially you can declare both head and tail list pointers local to the function (the tail pointer is temporary used to build the list) and then return head when done for assignment back in the caller (main() here). So all you really needed would be to declare your list pointers, and then add each node in-order, e.g.
struct node *head = NULL, *tail = NULL; /* temporary list pointers */
...
if (head == NULL) /* add first node */
head = tail = ptr;
else {
tail->next = ptr; /* set last node ->next to new node */
tail = ptr; /* update tail to new node */
}
...
return head; /* return pointer to start of list */
Then in main() you would simply call create_poly_list() for each polynomial, e.g.
p1 = create_poly_list();
p2 = create_poly_list();
Now let's tidy it up so you validate each input and allocation, returning NULL on either input or allocation failure (and remembering to free() all memory if memory was allocated prior to the failure to prevent a memory leak), e.g.
struct node *create_poly_list (void) /* no parameter required */
{
int i, n;
struct node *head = NULL, *tail = NULL; /* temporary list pointers */
fputs ("\nEnter the number of nodes: ", stdout);
if (scanf("%d", &n) != 1)
return NULL;
for (i = 0; i < n; i++)
{
struct node *ptr = malloc (sizeof *ptr);
if (!ptr) { /* validate EVERY allocation */
while (head) { /* if nodes in list */
struct node *victim = head; /* free all nodes (or leak) */
head = head->next;
free (victim);
}
return NULL; /* now return NULL on error */
}
ptr->next = NULL; /* initialize next ptr NULL */
fputs ("\nEnter the coefficient (a for a*x^b) : ", stdout);
if (scanf ("%d", &ptr->coeff) != 1) {
fputs ("error: invalid integer input.\n", stderr);
/* you would likewise need to free prior nodes here */
return NULL;
}
fputs ("Enter the exponent/power (b for a*x^b): ", stdout);
if (scanf("%d", &ptr->exp) != 1) {
fputs ("error: invalid integer input.\n", stderr);
/* you would likewise need to free prior nodes here */
return NULL;
}
if (head == NULL) /* add first node */
head = tail = ptr;
else {
tail->next = ptr; /* set last node ->next to new node */
tail = ptr; /* update tail to new node */
}
}
return head; /* return pointer to start of list */
}
Your display() function was good, but you should check if ptr is NULL (e.g. list empty) to inform the user of the list state in case an attempt is made to display an empty list, e.g.
void display (char const *tag, struct node *ptr)
{
if (!ptr) { /* validate list not NULL */
puts ("(list-empty)");
return;
}
struct node *temp = ptr;
printf("%s: ", tag);
while (temp) {
printf("-->(%d X %d)--E", temp->coeff, temp->exp);
temp = temp->next;
}
putchar('\n');
}
Here you need to free the memory of each list when you are done with it. (yes, the memory will be freed on program exit, but presumably you won't always be writing simple programs that create all lists in main()). Build good memory management habits early. A simple delete list function is all you need, e.g.
void del_list (struct node *list)
{
while (list) {
struct node *victim = list;
list = list->next;
free (victim);
}
}
Putting it altogether, you would have:
#include <stdio.h>
#include <stdlib.h>
struct node {
int exp;
int coeff;
struct node *next;
};
struct node *create_poly_list (void) /* no parameter required */
{
int i, n;
struct node *head = NULL, *tail = NULL; /* temporary list pointers */
fputs ("\nEnter the number of nodes: ", stdout);
if (scanf("%d", &n) != 1)
return NULL;
for (i = 0; i < n; i++)
{
struct node *ptr = malloc (sizeof *ptr);
if (!ptr) { /* validate EVERY allocation */
while (head) { /* if nodes in list */
struct node *victim = head; /* free all nodes (or leak) */
head = head->next;
free (victim);
}
return NULL; /* now return NULL on error */
}
ptr->next = NULL; /* initialize next ptr NULL */
fputs ("\nEnter the coefficient (a for a*x^b) : ", stdout);
if (scanf ("%d", &ptr->coeff) != 1) {
fputs ("error: invalid integer input.\n", stderr);
/* you would likewise need to free prior nodes here */
return NULL;
}
fputs ("Enter the exponent/power (b for a*x^b): ", stdout);
if (scanf("%d", &ptr->exp) != 1) {
fputs ("error: invalid integer input.\n", stderr);
/* you would likewise need to free prior nodes here */
return NULL;
}
if (head == NULL) /* add first node */
head = tail = ptr;
else {
tail->next = ptr; /* set last node ->next to new node */
tail = ptr; /* update tail to new node */
}
}
return head; /* return pointer to start of list */
}
void display (char const *tag, struct node *ptr)
{
if (!ptr) { /* validate list not NULL */
puts ("(list-empty)");
return;
}
struct node *temp = ptr;
printf("%s: ", tag);
while (temp) {
printf("-->(%d X %d)--E", temp->coeff, temp->exp);
temp = temp->next;
}
putchar('\n');
}
void del_list (struct node *list)
{
while (list) {
struct node *victim = list;
list = list->next;
free (victim);
}
}
int main(void)
{
struct node *p1 = NULL, *p2 = NULL;
p1 = create_poly_list();
p2 = create_poly_list();
putchar ('\n');
display("p1", p1);
display("p2", p2);
del_list (p1);
del_list (p2);
return 0;
}
(note: why you have included string.h is a bit bewildering...)
Example Use/Output
$ ./bin/poly_list
Enter the number of nodes: 2
Enter the coefficient (a for a*x^b) : 2
Enter the exponent/power (b for a*x^b): 6
Enter the coefficient (a for a*x^b) : 3
Enter the exponent/power (b for a*x^b): 7
Enter the number of nodes: 3
Enter the coefficient (a for a*x^b) : 1
Enter the exponent/power (b for a*x^b): 3
Enter the coefficient (a for a*x^b) : 3
Enter the exponent/power (b for a*x^b): 5
Enter the coefficient (a for a*x^b) : 5
Enter the exponent/power (b for a*x^b): 7
p1: -->(2 X 6)--E-->(3 X 7)--E
p2: -->(1 X 3)--E-->(3 X 5)--E-->(5 X 7)--E
Memory Use/Error Check
In any code you write that dynamically allocates memory, you have 2 responsibilities regarding any block of memory allocated: (1) always preserve a pointer to the starting address for the block of memory so, (2) it can be freed when it is no longer needed.
It is imperative that you use a memory error checking program to ensure you do not attempt to access memory or write beyond/outside the bounds of your allocated block, attempt to read or base a conditional jump on an uninitialized value, and finally, to confirm that you free all the memory you have allocated.
For Linux valgrind is the normal choice. There are similar memory checkers for every platform. They are all simple to use, just run your program through it.
$ valgrind ./bin/poly_list
==23402== Memcheck, a memory error detector
==23402== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==23402== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==23402== Command: ./bin/poly_list
==23402==
Enter the number of nodes: 2
Enter the coefficient (a for a*x^b) : 2
Enter the exponent/power (b for a*x^b): 6
Enter the coefficient (a for a*x^b) : 3
Enter the exponent/power (b for a*x^b): 7
Enter the number of nodes: 3
Enter the coefficient (a for a*x^b) : 1
Enter the exponent/power (b for a*x^b): 3
Enter the coefficient (a for a*x^b) : 3
Enter the exponent/power (b for a*x^b): 5
Enter the coefficient (a for a*x^b) : 5
Enter the exponent/power (b for a*x^b): 7
p1: -->(2 X 6)--E-->(3 X 7)--E
p2: -->(1 X 3)--E-->(3 X 5)--E-->(5 X 7)--E
==23402==
==23402== HEAP SUMMARY:
==23402== in use at exit: 0 bytes in 0 blocks
==23402== total heap usage: 7 allocs, 7 frees, 2,128 bytes allocated
==23402==
==23402== All heap blocks were freed -- no leaks are possible
==23402==
==23402== For counts of detected and suppressed errors, rerun with: -v
==23402== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Always confirm that you have freed all memory you have allocated and that there are no memory errors.
Look things over and let me know if you have further questions.

Answer 2

I might be wrong, but in the function
struct node *create_new_nodes(struct node *m)
it looks like both the return type and the parameter are pointers. So really, you are returning
struct node **m
Not sure if that's what's wrong, but if it is, the same issue might appear when you do
printf("-->(%d X %d)--E", temp->coeff, temp->exp);
when temp is ptr which is struct node*. So really you are saying (**node).coeff. But this is just my tired observation, if it works just ignore me.