Insert node not values in end of linked lists - c

Question

Lets say I have some linked lists already available and I want to store first node of each individual list into another list so that I can recall this list to display the original lists. I think we have to use two different structures. I am already successful in retaining original lists and displaying them using Array of first nodes of individual lists but I want to create a linked list of individual list to implement same. It has the expected output but as I said I want to use linked list instead of array of nodes.
Now this is how I am trying to solve the problem to replace the array of linked lists to linked list of first nodes, I am getting crashes whenever I try to debug code. Please help me.
#include <stdio.h>
#include <stdlib.h>
struct node{
int number;
struct node*next;
};
typedef struct node Node;
Node* insertValue(Node * list, int value);
void display(Node*);
struct list_of_nodes {
Node *list;
struct list_of_nodes *next;
};
typedef struct list_of_nodes ListNode;
ListNode* insertNode(ListNode* head,Node* node);
int main()
{
ListNode *head=NULL;
Node *globalList = NULL, *lists[100];
int nbrOfLists, listNo, nbrOfVal, valNo, val,i=0,k;
CHECKER:
printf("\n\n Enter the number of lists (1 to 100):");
scanf("%d", &nbrOfLists);
if(nbrOfLists <= 0 || nbrOfLists > 100) //handling exceptional cases
{
printf("\n \n Number of Lists should be between 1 to 100"); // since array of node pointers contains 100 elements
goto CHECKER;
}
for(listNo = 0; listNo < nbrOfLists; listNo++)
{
printf("\n\n Enter the number of inputs to the list %d: \n ",listNo+1);
scanf("%d", &nbrOfVal);
lists[listNo] = NULL;
for(valNo = 0; valNo < nbrOfVal; valNo++) // to enter values in each individual list
{
printf("Enter node value %d:", valNo+1);
scanf("%d", &val);
// Here we insert the value in both lists
lists[listNo]= insertValue(lists[listNo], val); // original list has to be retained so storing in array lists
globalList = insertValue(globalList, val); // inserting node in combined list. This prevents an extra loop and merges the list elements into one.
}
head=insertNode(head,lists[listNo]); // CRASHING HERE
printf("\n The list %d is: ",listNo+1);
display(lists[listNo]); // display each list after input
}
printf("\n\n\n THE FINAL LIST IS: ");
display(globalList); //display combined list
printf("\n\n THE LISTS WERE: ");
while(i<nbrOfLists){ //original lists displayed
k=i+1;
printf("\n\n The list %d is: ",k);
display(lists[i]);
i++;
}
printf("\n\n");
return 0;
}
ListNode* insertNode(ListNode* head, Node* node){
ListNode *newNode, *m;
newNode = malloc(sizeof(ListNode));
newNode->list=node;
if(newNode == NULL)
{
newNode->next=NULL; // inserting first node
return newNode;
}
m = head;
while(m->next) // checking for right position in ordered list for new node
{
m = m->next;
}
newNode->next = m->next; // inserting new node
m->next = newNode;
return head;
}
Node* insertValue(Node * list, int value) // function to insert node in ordered manner into list
{
Node *newNode, *m;
newNode = malloc(sizeof(Node));
newNode->number=value;
if(list == NULL)
{
newNode->next=NULL; // inserting first node
return newNode;
}
if(value < list->number)
{
newNode->next = list; // inserting in end
return newNode;
}
m = list;
while(m->next) // checking for right position in ordered list for new node
{
if(value < m->next->number)
break;
m = m->next;
}
newNode->next = m->next; // inserting new node
m->next = newNode;
return list;
}
void display(Node*nodex){ // display node values in list
printf("%d ->",nodex->number);
nodex=nodex->next;
if(nodex)
return display(nodex);
else
return 0;
}
Here is the code which shows expected results but with Array of nodes:
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
struct node{
int number;
struct node*next;
};
typedef struct node Node;
Node* insertValue(Node *list, int value);
void display(Node*);
int main()
{
Node *globalList = NULL, *lists[100];
int nbrOfLists, listNo, nbrOfVal, valNo, val, i = 0, k;
CHECKER:
printf("\n\n Enter the number of lists (1 to 100):");
scanf("%d", &nbrOfLists);
if(nbrOfLists <= 0 || nbrOfLists > 100) //handling exceptional cases
{
printf("\n \n Number of Lists should be between 1 to 100"); // since array of node pointers contains 100 elements
goto CHECKER;
}
for(listNo = 0; listNo < nbrOfLists; listNo++)
{
printf("\n\n Enter the number of inputs to the list %d: \n ", listNo + 1);
scanf("%d", &nbrOfVal);
lists[listNo] = NULL;
for(valNo = 0; valNo < nbrOfVal; valNo++) // to enter values in each individual list
{
printf("Enter node value %d:", valNo + 1);
scanf("%d", &val);
// Here we insert the value in both lists
lists[listNo] = insertValue(lists[listNo], val); // original list has to be retained so storing in array lists
globalList = insertValue(globalList, val); // inserting node in combined list. This prevents an extra loop and merges the list elements into one.
}
printf("\n The list %d is: ", listNo + 1);
display(lists[listNo]); // display each list after input
}
printf("\n\n\n THE FINAL LIST IS: ");
display(globalList); //display combined list
printf("\n\n THE LISTS WERE: ");
while(i < nbrOfLists){ //original lists displayed
k = i + 1;
printf("\n\n The list %d is: ", k);
display(lists[i]);
i++;
}
printf("\n\n");
return 0;
}
Node* insertValue(Node *list, int value) // function to insert node in ordered manner into list
{
Node *newNode, *m;
newNode = malloc(sizeof(Node));
newNode->number = value;
if(list == NULL)
{
newNode->next = NULL; // inserting first node
return newNode;
}
if(value < list->number)
{
newNode->next = list; // inserting in end
return newNode;
}
m = list;
while(m->next) // checking for right position in ordered list for new node
{
if(value < m->next->number)
break;
m = m->next;
}
newNode->next = m->next; // inserting new node
m->next = newNode;
return list;
}
void display(Node *nodex){ // display node values in list
printf("%d ->", nodex->number);
nodex = nodex->next;
if(nodex)
return display(nodex);
else
return 0;
}
Please let me know if you do not understood the problem.

Answer 1

After considerable discussion in chat, I ended up using this code which is closely related to the last version in the question:
#include <stdio.h>
#include <stdlib.h>
struct node
{
int number;
struct node *next;
};
typedef struct node Node;
Node *insertValue(Node *list, int value);
void display(Node *);
struct list_of_nodes
{
Node *list;
struct list_of_nodes *next;
};
typedef struct list_of_nodes ListNode;
ListNode *insertNode(ListNode *head, Node *node);
int main(void)
{
ListNode *head = NULL;
Node *globalList = NULL, *lists[100];
int nbrOfLists, listNo, nbrOfVal, valNo, val, i = 0, k;
CHECKER:
printf("\n\n Enter the number of lists (1 to 100):");
scanf("%d", &nbrOfLists);
if (nbrOfLists <= 0 || nbrOfLists > 100)
{
printf("\n \n Number of Lists should be between 1 to 100");
goto CHECKER;
}
for (listNo = 0; listNo < nbrOfLists; listNo++)
{
printf("\n\n Enter the number of inputs to the list %d: \n ", listNo + 1);
scanf("%d", &nbrOfVal);
lists[listNo] = NULL;
for (valNo = 0; valNo < nbrOfVal; valNo++)
{
printf("Enter node value %d:", valNo + 1);
scanf("%d", &val);
lists[listNo] = insertValue(lists[listNo], val);
globalList = insertValue(globalList, val);
}
head = insertNode(head, lists[listNo]);
printf("\n The list %d is: ", listNo + 1);
display(lists[listNo]);
}
printf("\n\n\n THE FINAL LIST IS: ");
display(globalList);
printf("\n\n THE LISTS WERE: ");
while (i < nbrOfLists)
{
k = i + 1;
printf("\n\n The list %d is: ", k);
display(lists[i]);
i++;
}
printf("\n\n");
return 0;
}
ListNode *insertNode(ListNode *head, Node *node)
{
ListNode *newNode, *m;
newNode = malloc(sizeof(ListNode));
newNode->list = node;
newNode->next = NULL;
if (newNode == NULL)
{
fprintf(stderr, "Out of memory in %s\n", __func__);
exit(1);
}
if (head == NULL)
return newNode;
m = head;
while (m->next)
{
m = m->next;
}
newNode->next = m->next;
m->next = newNode;
return head;
}
Node *insertValue(Node *list, int value)
{
Node *newNode, *m;
newNode = malloc(sizeof(Node));
newNode->number = value;
newNode->next = NULL;
if (list == NULL)
return newNode;
if (value < list->number)
{
newNode->next = list;
return newNode;
}
m = list;
while (m->next)
{
if (value < m->next->number)
break;
m = m->next;
}
newNode->next = m->next;
m->next = newNode;
return list;
}
void display(Node *nodex)
{
printf("%d ->", nodex->number);
nodex = nodex->next;
if (nodex)
display(nodex);
}
With a sample data file (ll7.data):
3
6 26 22 83 96 89 69
10 87 33 5 36 85 34 0 25 57 99
5 49 44 27 75 82
I compiled ll7.c above using:
$ gcc -O3 -g -std=c11 -Wall -Wextra -Werror ll7.c -o ll7
$
And ran it under valgrind which noted that the code leaks like a sieve (because there isn't a free in sight), but otherwise gave it a clean bill of health.
$ valgrind --suppressions=suppressions ./ll7 < ll7.data
==7696== Memcheck, a memory error detector
==7696== Copyright (C) 2002-2013, and GNU GPL'd, by Julian Seward et al.
==7696== Using Valgrind-3.11.0.SVN and LibVEX; rerun with -h for copyright info
==7696== Command: ./ll7
==7696==
--7696-- UNKNOWN mach_msg unhandled MACH_SEND_TRAILER option
--7696-- UNKNOWN mach_msg unhandled MACH_SEND_TRAILER option (repeated 2 times)
--7696-- UNKNOWN mach_msg unhandled MACH_SEND_TRAILER option (repeated 4 times)
Enter the number of lists (1 to 100):
Enter the number of inputs to the list 1:
Enter node value 1:Enter node value 2:Enter node value 3:Enter node value 4:Enter node value 5:Enter node value 6:
The list 1 is: 22 ->26 ->69 ->83 ->89 ->96 ->
Enter the number of inputs to the list 2:
Enter node value 1:Enter node value 2:Enter node value 3:Enter node value 4:Enter node value 5:Enter node value 6:Enter node value 7:Enter node value 8:Enter node value 9:Enter node value 10:
The list 2 is: 0 ->5 ->25 ->33 ->34 ->36 ->57 ->85 ->87 ->99 ->
Enter the number of inputs to the list 3:
Enter node value 1:Enter node value 2:Enter node value 3:Enter node value 4:Enter node value 5:
The list 3 is: 27 ->44 ->49 ->75 ->82 ->
THE FINAL LIST IS: 0 ->5 ->22 ->25 ->26 ->27 ->33 ->34 ->36 ->44 ->49 ->57 ->69 ->75 ->82 ->83 ->85 ->87 ->89 ->96 ->99 ->
THE LISTS WERE:
The list 1 is: 22 ->26 ->69 ->83 ->89 ->96 ->
The list 2 is: 0 ->5 ->25 ->33 ->34 ->36 ->57 ->85 ->87 ->99 ->
The list 3 is: 27 ->44 ->49 ->75 ->82 ->
==7696==
==7696== HEAP SUMMARY:
==7696== in use at exit: 43,752 bytes in 471 blocks
==7696== total heap usage: 551 allocs, 80 frees, 49,880 bytes allocated
==7696==
==7696== LEAK SUMMARY:
==7696== definitely lost: 32 bytes in 2 blocks
==7696== indirectly lost: 688 bytes in 43 blocks
==7696== possibly lost: 0 bytes in 0 blocks
==7696== still reachable: 29,998 bytes in 310 blocks
==7696== suppressed: 13,034 bytes in 116 blocks
==7696== Rerun with --leak-check=full to see details of leaked memory
==7696==
==7696== For counts of detected and suppressed errors, rerun with: -v
==7696== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
$
The prompting output isn't really wanted when the input comes from a file, and that's why the numbers aren't seen, too. When you type at the terminal, the terminal driver echoes what you type to the screen. When the data comes from a file, you don't see the characters as they're read.
The suppressions file lists and suppresses a variety of leaks from the Mac OS X 10.10.3 Yosemite runtime system. That's why there's so much memory in use, too; the runtime system uses a lot of memory.
Were it all my code, there'd be a lot that would be done differently. There is a lot of error checking that should be added and refactorization (especially 'extract function') that could/should be done, but those changes were not made to preserve some semblance to the code posted in the question.

Answer 2

Update: Just about 5 minutes before I finished this,
a new version of the code was posted
that seems to do what I recommended, but the new function was not quite right.
Here is one problem:
ListNode* insertNode(ListNode* head, Node* node){
// ... other code here ...
m = head;
while(m->next)
The first time insertNode is called, head is a null pointer
(which it should be, because the list of lists is still empty at that time).
So this sets m to a null pointer, and then attempts to access m->next ... oops!
I see this comment:
// checking for right position in ordered list for new node
Why? What is the "right position"? It appears that the "right position" is
the end of the list of lists; but what is wrong with the beginning?
If you absolutely must have the list of lists come out in the same order in
which the lists were input, then a simpler and more efficient design is to
insert each new list at the start of the list of lists, and when you are
all done, reverse the list of lists.
But you could also just adapt the code from insertValue a little more
carefully. Compare this code of insertValue:
newNode = malloc(sizeof(Node));
newNode->number=value;
if(list == NULL)
to this code of insertNode:
newNode = malloc(sizeof(ListNode));
newNode->list=node;
if(newNode == NULL)
Do you see the difference? In insertValue the if tests the pointer that was passed into the function; in insertNode the if tests the pointer that you have just assigned by newNode = malloc(sizeof(ListNode)).
Of course if(newNode == NULL) will never execute the body of the if
(unless something has already gone badly wrong).
What you need is to test if(head == NULL) so that you can handle
that case correctly.
The rest of this refers to the older version of the question.
Among other things that probably aren't doing what they're supposed to,
this piece of code has multiple serious flaws:
if(valNo==0){ // FOR EVERY FIRST NODE IN INDIVIDUAL LIST, I AM TRYING TO INSERT IT INTO LIST OF FIRST NODES
head->list=malloc(sizeof(Nodex));
head->list=lists[listNo];
head=head->next;
}
OK, first major flaw, you are trying to add the new list to the list of lists
before the list is complete. Until the list is complete, you don't know
what node will end up at the head of that list. The first node you insert
into the list could end up anywhere in the completed list.
That is not what you want to put in your list of lists.
One thing you should change in the code, therefore, is to move those lines
(the ones I copied) out of the inner for loop where they are now;
put them after the end of that loop instead
(and of course delete the if(valNo==0);
these lines should execute unconditionally).
Next thing, you never allocated a Nodex for head to point to,
so head->list will always be an access error.
Next thing, head->list=lists[listNo] overwrites the pointer you just
set with head->list=malloc(sizeof(Nodex)); the memory you allocated
with malloc(sizeof(Nodex)) is immediately leaked. (It was allocated using
the size of the wrong type anyway, since list was supposed to point to a
Node rather than a Nodex, although the Nodex is probably at least
large enough so you could get away with that mistake.)
Finally: head=head->next;??? Since head is the only Nodex* that you
declared at the start of the main() function, if there were ever a
legitimate Nodex in your list, after head=head->next
there would be nothing pointing to that Nodex any more, at least
nothing that you can find in your program. So if you succeeded in putting
anything in the list of lists, that step would essentially throw it away
(it would become a memory leak).
What you probably should do, for your sanity, is write a function
Nodex* insertList(Nodex* list_list, Node* value_list)
that inserts the head pointer of a list, value_list,
into your list of lists, analogously to the way
Node* insertValue(Node * list, int value) inserts a number into a list,
except that you probably don't need to make insertList keep its list
"sorted", so insertList should be considerably simpler than insertValue.
(In fact it will be so simple that you may be tempted to just write
the code of that function inline in your main function. I suggest you
resist the temptation; writing the code inline did not work for you on
the first attempt, and making even very simple functions to do well-defined
things is a good practice.)