linkedlist: count=count->next gives segmentation fault - c

Question

#include<stdio.h>
#include<malloc.h>
typedef struct nde{
int data;
struct nde *next;
}node,*pnode;
void inst_beg(node *,int);
void inst_end(node *,int);
void inst_any(node *,int,int);
int del_begin(node *);
int del_end(node *);
int del_any(node*,int);
void display(node *);
main()
{
pnode head= (node *)malloc(1*sizeof(node));
head->data=0;
head->next=NULL;
inst_any(head,1,1);
inst_any(head,2,2);
// inst_any(head,3,3);
display(head);
}
void inst_any(node *head,int pos, int data){
pnode nd=(node *)malloc(1*sizeof(node));
nd->data=data;
//pnode count=(node *)malloc(1*sizeof(node));
pnode count;
count=head;
printf("head: %p",head);
printf("count: %p",count);
int i=0;
while(i<pos-1){
count=count->next; //Problem is here for inst_any(phead,2,2)
}
nd->next=count->next;
count->next=nd;
//printf("done");
}
void display(node * head){
pnode count=head;
while(count->next!=NULL){
printf("%d",count->data);
count=count->next;
}
}
Value of count is becoming null inside loop so we are not able to deference it when it is coming second time when inst_any(head,2,2) is being called. Checked with gdb that first time count is successfully being pointed to head. And same is happening for second time also. After count=head it is giving correct value for second time. Dont know what is happening after that. Why when its coming inside the loop count's value is becoming zero.

Answer 1

Look at this code:
while(i<pos-1){
count=count->next; //Problem is here for inst_any(phead,2,2)
}
That's the whole loop. So either your condition i<pos-1 is false right away .... or it is true and stays true, as you never modify i nor pos in your loop.
In the latter case, you walk a linked list. Eventually, you'll find the end (count->next is NULL) and still assign this NULL to count. In the next iteration, you try to dereference NULL to access ->next. Trying to dereference NULL is undefined behavior, a segmentation fault is a typical consequence.
Go and rethink your program (e.g., check whether count->next is still not NULL in your loop condition).

Answer 2

I have corrected your code with comments below. Please read my comments in the codes else you can not realize your mistakes. Hope this will help you.
typedef struct nde{
int data;
struct nde *next;
}node,*pnode;
void inst_beg(node *,int);
void inst_end(node *,int);
void inst_any(node *,int,int);
int del_begin(node *);
int del_end(node *);
int del_any(node*,int);
void display(node *);
void main()
{
pnode head= (node *)malloc(sizeof(node)); //No need to multiply by one
head->data=0;
head->next=NULL;
inst_any(head,1,1);
inst_any(head,2,2);
inst_any(head,3,3);
display(head);
inst_any(head,4,4); //I am adding this statement so that you can better understand where it going to be inserted
display(head);
inst_any(head,7,7);
}
void inst_any(node *head,int pos, int data){
pnode nd=(node *)malloc(sizeof(node));
nd->data=data;
//pnode count=(node *)malloc(1*sizeof(node));
pnode count;
count=head;
printf("head: %p\n",head);
printf("count: %p\n",count);
int i=0;
while(i < (pos-1)){
if(count == NULL){
printf("No position available for request pos =%d\n", pos);
return;//This condition is important. If your position is not exist in the list and count reached the end of the list just return with a error message
}
count=count->next; //Problem is here for inst_any(phead,2,2)
i++;//you must increment i
}
nd->next=count->next;
count->next=nd;//Here count must not be null, else it will create Segmentation fault. Therefore inside from while loop above we have checked whether it is null or not. If null return from this method.
//printf("done\n");
}
void display(node * head){
pnode count=head;
while(count!=NULL){//You have to correct it to print last node of the list
printf("%d\n",count->data);
count=count->next;
}
}

Answer 3

the posted code for the function: inst_any() initializes the data field, but fails to initialize the next field.
Suggest:
nd->data=data;
nd->next = NULL;
Then this loop:
while(i<pos-1){
count=count->next; //Problem is here for inst_any(phead,2,2)
}
fails to update the counter i so the loop never exits. Also, when the linked list does not contain enough entries this loop will run right off the end of the list. So the loop also needs to be checking that the count->next is not NULL.