Linked List Insertion Simple - c

Question

#include <stdio.h>
#include <stdlib.h>
typedef struct node{
int key;
struct node* next;
} node_t;
typedef node_t* node_ptr;
void main()
{
node_ptr p = NULL;
node_ptr listhead =NULL;
/*need to create a listhead with key = 1,2,3..10*/
int i;
for (i =1; i<= 10;i ++)
{
node_ptr temp;
p =(node_ptr)malloc(sizeof(node_t));
p->key = i;
p->next = NULL;
if( list_head == NULL )
{
list_head= p;
}
else
{
temp = listhead;
while(temp->next != NULL)
{
temp = temp->next;
}
temp->next = p;
}
}
}
I am still pretty confused about linked list and I am not sure if I'm doing correctly and pretty sure it is wrong, could anyone help me out? This is just
a practice question :)
And also uptil the line of node_ptr listhead=NULL; is given in the question so i cannot change the stuffs above that.
By the way just to be clear, the question asks to insert keys 1,2,3..10 to the listhead.

Answer 1

"Insert" can imply inserting at the start of a list rather than at some point in the list or at the end of a list. For this assignment, what is "insert" supposed to mean?
Example code with for loop and minor changes like using node_ptr instead of node_t * to correspond with assignment typedef, and int main() instead of void main().
#include <stdlib.h>
typedef struct node{
int key;
struct node* next;
} node_t;
typedef node_t* node_ptr;
int main()
{
node_ptr list_head = NULL;
node_ptr p;
node_ptr temp;
int i;
/* create a list with keys = 1,2,3..10 */
for (i = 1; i <= 10; i++)
{
p = (node_ptr)malloc(sizeof(node_t));
p->key = i;
p->next = NULL;
if( list_head == NULL )
{
list_head= p;
}
else
{
for(temp = list_head; temp->next != NULL; temp = temp->next);
temp->next = p;
}
}
return 0;
}
Alternate version using pointer to pointer to node. This eliminates the initial check for list_head == NULL. It's beyond what you'd be using now for the assignment, but knowing how to do this could be useful in later assignments.
#include <stdlib.h>
typedef struct node{
int key;
struct node* next;
} node_t;
typedef node_t* node_ptr;
typedef node_t ** node_ptr_ptr;
int main()
{
node_ptr list_head = NULL;
node_ptr p;
/* ptr to either list_head or to last node.next */
node_ptr_ptr pptemp;
int i;
/* create a list with keys = 1,2,3..10 */
for (i = 1; i <= 10; i++)
{
p = (node_ptr)malloc(sizeof(node_t));
p->key = i;
p->next = NULL;
for(pptemp = &list_head; *pptemp != NULL; pptemp = &(*pptemp)->next);
*pptemp = p;
}
return 0;
}
For this particular case, since temp (or pptemp) is in main, it only needs to be initialized once and advanced once per loop:
#include <stdlib.h>
typedef struct node{
int key;
struct node* next;
} node_t;
typedef node_t* node_ptr;
typedef node_t ** node_ptr_ptr;
int main()
{
node_ptr list_head = NULL;
node_ptr p;
/* ptr to either list_head or to last node.next */
node_ptr_ptr pptemp = &list_head;
int i;
/* create a list with keys = 1,2,3..10 */
for (i = 1; i <= 10; i++)
{
p = (node_ptr)malloc(sizeof(node_t));
p->key = i;
p->next = NULL;
*pptemp = p;
pptemp = &p->next;
}
return 0;
}