Seg fault linked list recursion in C - c

Question

I can't figure out why I'm seg faulting. The basic idea is to insert integers in order recursively using a linked list.
node* insert(node** head, int integer)
{
node* temp = malloc(sizeof(node));
node* temp1;
node* newNode;
if(*head == NULL)
{
temp->num = integer;
temp->next = *head;
*head = temp;
}
else if((*head)->num > integer)
{
temp = *head;
temp1 = temp->next; //breaks the link
temp->next = newNode; //creates a new node
newNode->num = integer; //adds int
newNode->next = temp1; //links new node to previously broken node
temp1->next = *head; //next node is NULL
*head = temp1; //Makes next node head again
}
else
insert(&((*head)->next), integer);
return(temp);
}
I ran this code in GDB and it seg faults at temp1->next = *head but I don't understand why. I even put notes to help myself but I guess it isn't working. Can someone please tell me why I'm seg faulting? Thanks.

Answer 1

temp1 = temp->next;
should be before
temp = *head;
In case that the (*head)->num > integer and If you want to insert the integer in the header than your code is complicated and wrong. you can do it in this way:
else if((*head)->num > integer)
{
temp->next = *head;
temp->num = integer;
*head = temp;
}
and the
temp = malloc(sizeof(node));
should be called only into the
if(*head == NULL)
and into
else if((*head)->num > integer)
So your final function could be like this
node* insert(node** head, int integer)
{
node* temp;
if(*head == NULL)
{
temp = malloc(sizeof(node));
temp->num = integer;
temp->next = *head;
*head = temp;
}
else if((*head)->num > integer)
{
temp = malloc(sizeof(node));
temp->next = *head;
temp->num = integer;
*head = temp;
}
else
temp = insert(&((*head)->next), integer);
return(temp);
}
I test the insert function with:
int main (void) {
node *tmp, *head = NULL;
insert(&head, 5);
insert(&head, 7);
insert(&head, 3);
insert(&head, 6);
insert(&head, 4);
insert(&head, 2);
for (tmp = head; tmp!=NULL; tmp = tmp->next) {
printf("tmp->num %d\n",tmp->num);
}
}
and it works succefully!
$ ./test
tmp->num 2
tmp->num 3
tmp->num 4
tmp->num 5
tmp->num 6
tmp->num 7

Answer 2

So the first time you go through this, head is null and you've got a case for that.
The next time through, head has a pointer, and there is no next node. The head->next is NULL.
So when you get to:
temp1 = temp->next;
That's setting it equal to NULL. And when you get to
temp1->next = *head; //next node is NULL
Whoa there, temp1 is null. There is no such thing as temp1->next, that's looking for a structure where there is none.
Edit:
And you're throwing away the memory you just allocated when you set temp = *head. You probably shouldn't be allocating memory until you're sure you need it. I mean, you call a new instance of insert() every time the number is less than the target. Each pass you allocate some memory that you don't actually use. And you probably wanted to allocate memory for newnode, not temp.
And you should probably use a better naming scheme. I mean, the second time you call insert, it's no longer the head. integer could be something more like intToInsert or newValue. temp1 is more like savedTail. Minor issue, but it helps keep things straight, and it's a good habit to get into.
Finally, think about what happens when you've gone through the list, found where the new item belongs, made a new node, set it's ->next field to the rest of the tail, and returned. ... now what? the previous node has a next value that's still pointing to what it was before. You need to update that link as well.

Answer 3

Lets assume that the linked list currently has only one node.
So *head = some node.
*head->next = NULL.
Now lets look into the code:
node* insert(node** head, int integer)
{
node* temp = malloc(sizeof(node));
node* temp1;
node* newNode;
if(*head == NULL) // condition = false
{
temp->num = integer;
temp->next = *head;
*head = temp;
}
else if((*head)->num > integer) // let's assume condition = true
{
temp = *head;
temp1 = temp->next; //breaks the link // temp1 = NULL
temp->next = newNode; //creates a new node // temp1 is not changed
newNode->num = integer; //adds int
newNode->next = temp1; //links new node to previously broken node
temp1->next = *head; //next node is NULL // NULL->next !!!
*head = temp1; //Makes next node head again
}
else
insert(&((*head)->next), integer);
return(temp);
}

Answer 4

*head = temp1;
should be before
temp1->next = *head;