Printing contents of linked list only prints first node - c

Question

This is the updated version of the code. i am trying to add some info in a link list every time a client sends a message to the server (it can be multiple clients). Every time a new message arrives, the function checks its time so it could add it to the list before or after the previous node depending on its current time. The server must print the messages in order of arrival. If there are equal time stamps then it should move to sort the equal ones in using the ids of the servers.
Here is my struct for the list:
'typedef struct trade_list {
char* trader_msg;
u_int32_t id_of_sender;
int sender_timer;
int local_time;
struct trade_list *next;
}trade_list;
trade_list *head = NULL;
the following is the function that inserts to list and sorts according to time:
void add_transaction (char* received_msg_IN, int curr_time_IN, u_int32_t my_id_IN, int elapsedIn)
{
/* Find the node with the smallest time >= curr_time_IN. 'found' starts as NULL, then
is always the node before 'cur'. 'cur' moves through the list until its time is
less than 'curr_time_IN'. So at the end, 'cur' is the first node that's too
far in, and 'found' is either NULL or the node we insert after. */
trade_list *newnode, *cur, *found;
found = NULL;
for (cur = head; cur && cur->sender_timer <= curr_time_IN; cur = cur->next)
found = cur;
if (found) {
/* If 'found' isn't NULL, we're inserting after it*/
/* Times match: Sort out in another way*/
} else {
newnode = malloc(sizeof(*newnode));
newnode->trader_msg = malloc(strlen(received_msg_IN)*sizeof(received_msg_IN));
strcpy(newnode->trader_msg,received_msg_IN);
newnode->sender_timer = curr_time_IN;
newnode->id_of_sender = my_id_IN;
newnode->local_time = elapsedIn;
newnode->next = found->next;
found->next = newnode;
}
} else {
/* No node with more recent time found -- inserting at 'head' */
newnode = malloc(sizeof(*newnode));
newnode->trader_msg = malloc(strlen(received_msg_IN)*sizeof(received_msg_IN));
strcpy(newnode->trader_msg,received_msg_IN);
newnode->sender_timer = curr_time_IN;
newnode->id_of_sender = my_id_IN;
newnode->local_time = elapsedIn;
newnode->next = head;
head = newnode;
}
EDITED AFTER NEW PROBLEM
I managed to sort the list using a sorting method instead later on. So now my list gets sorted just fine. It prints just fine swell, the new problem that arose now is that I want to delete the current node after I print it. So after it gets print it gets deleted. I used the following function but my app crashes.
void deletefirst (struct trade_list *head) {
struct trade_list *tmp = *head;
if (tmp == NULL) return;
*head = tmp->next;
free (tmp);
}
i call this function from my print function:
void print_trades()
{
trade_list * newnode = head;
while (newnode) {
if ((elapsed - newnode->local_time >= 8))
{
printf ("%s\n", newnode->trader_msg);
newnode = newnode->next;
deletefirst(newnode);
}
}
}
How would I delete the current node and move on?

Answer 1

The way you print the list should work fine, as long as there is at least one node. I'd recommend changing the do { ... } while() to just a while() { ... } though, so that it still works when the list is empty and head is NULL:
trade_list *currentnode = head;
while (currentnode) {
printf ("Trade: %s Time: %d ID: %d\n",
currentnode->trader_msg,
currentnode->sender_timer,
currentnode->id_of_sender);
currentnode = currentnode->next;
}
There are some problems with the way you add to the list, though. When head is not null, you're removing its link to the rest of your list:
if (head == NULL)
{
... /* skipped for brevity */
}
else
{
currentnode->next = NULL;
head = currentnode;
}
Since at this point currentnode == head, you're pointing head->next to NULL (if there were another node, you'd be throwing it away) and then assigning head to itself.
Your insertion code in general doesn't look right. If you want to insert only at the beginning of the list, you just need something like:
trade_list *newnode = malloc(sizeof(trade_list));
/* *** Fill out newnode's fields here *** */
newnode->next = head;
head = newnode;
If you want to insert after an arbitrary node, you have to find it first by walking the list, then do something like this (keeping later times at the head of the list):
trade_list *newnode, *cur, *found;
/* Find the node with the smallest time >= curr_time_IN. 'found' starts as NULL, then
is always the node before 'cur'. 'cur' moves through the list until its time is
less than 'curr_time_IN'. So at the end, 'cur' is the first node that's too far in,
and 'found' is either NULL or the node we insert after. */
found = NULL;
for (cur = head; cur && cur->sender_timer >= curr_time_IN; cur = cur->next)
found = cur;
if (found) {
/* If 'found' isn't NULL, we're inserting after it (or skipping if the times match,
since that seems to be what the original code was trying to do) */
if (found->sender_timer == curr_time_IN) {
/* Times match: skip it */
printf("SKIPPED\n");
} else {
/* inserting after 'found' */
newnode = malloc(sizeof(*newnode));
/* *** Fill out newnode's fields here *** */
newnode->next = found->next;
found->next = newnode;
}
} else {
/* No node with more recent time found -- inserting at 'head' */
newnode = malloc(sizeof(*newnode));
/* *** Fill out newnode's fields here *** */
newnode->next = head;
head = newnode;
}
Edited after comment:
To change the list to sort descending by time, then ascending by ID when the times match, just a couple of changes are needed.
Edit
Since the original for loop to find the node continues to the last node that meets the criteria, we just have to add a test into the loop to break when we're at the right one... that is, to break if the next node has equal time and a higher ID, since in that case we want to insert before it. (the earlier edit was flawed... sorry about that).
Additionally, the if (found->sender_timer == curr_time_IN) check afterwards is no longer needed, since there's no skipping and the sort by ID was handled by the new for loop.
So that section of code becomes:
/* original search */
for (cur = head; cur && cur->sender_timer >= curr_time_IN; cur = cur->next) {
/* *** added condition for ID sort */
if (cur->sender_timer == curr_time_IN && cur->id_of_sender >= my_id_IN) break;
found = cur;
}
if (found) {
/* If 'found' isn't NULL, we're inserting after it */
/* CHANGED: no need to skip when times are equal */
newnode = malloc(sizeof(*newnode));
/* *** Fill out newnode's fields here *** */
newnode->next = found->next;
found->next = newnode;
} else {
/* No node with more recent time found -- inserting at 'head' */
newnode = malloc(sizeof(*newnode));
/* *** Fill out newnode's fields here *** */
newnode->next = head;
head = newnode;
}

Answer 2

The problem is not with the printing code it is in the addition.
It looks like when adding a new node you allocate the node but does not connect it to the head or any of the other nodes.
You must have a code like this to add to the beginning of the list:
new_node->next = head;
head= new_node;
Also, the logic you used is obscured and you have many code duplications.
Adding to a linked list has only two options: beginning of the list (head) or on any of the other nodes, you do not need all this logic.