Doubly Linked List insertion before given element - c

Question

I am trying to learn how to correctly work with pointers in C. Currently, I am trying to create function that would insert new node before the one, which value is given. My function looks like this:
struct list *listAddBefore(struct list *element, int insertWhat, int insertBefore)
{
element = listToFirst(element);
while (element -> next)
{
if (element -> value == insertBefore)
{
struct list *temp = listCreateElement(insertWhat, element->prev, element);
element -> prev -> next = temp;
element -> prev = temp;
return temp;
}
element = element -> next;
}
return NULL;
}
struct list *listToFirst(struct list *element)
{
while (element -> prev)
element = element -> prev;
return element;
}
struct list *listCreateElement(int value, struct list *prev, struct list *next)
{
struct list *element = (struct list *) malloc(sizeof(struct list));
element -> value = value;
element -> prev = prev;
element -> next = next;
return element;
}
What is the problem? Compiler gives me segmentation error.

Answer 1

Your code has one important problem
while (element->next)
should be
while (element)
since for the first element element->next = NULL and hence your function will return NULL immediately. Then you will pass again the head element and repeat that behavior on every call to this function.
Here
element->prev->next = temp;
you will dereference element->prev which must be NULL for the first node, you must check if it is valid or not, otherwise you will cause a segmentation fault. This is the correct way to link the nodes though.
I fixed your code to help you learn how to work with linked lists
struct list *listToFirst(struct list *element)
{
if (element == NULL) /* check before dereferencing */
return NULL;
while (element->previous != NULL)
element = element->previous;
return element;
}
struct list *listCreateElement(int value, struct list *prev, struct list *next)
{
struct list *element = (struct list *)malloc(sizeof(struct list));
if (element == NULL) /* check the return value of malloc before dereference */
return NULL;
element->value = value;
element->previous = prev;
element->next = next;
/*
* here we test if there is a previous node, if there is one
* we relink the node to point to element as it's next node.
*/
if (prev != NULL)
prev->next = element;
return element;
}
struct list *listAddBefore(struct list *element, int insertWhat, int insertBefore)
{
element = listToFirst(element);
while (element != NULL) /* here is the most important fix */
{
if (element->value == insertBefore)
return listCreateElement(insertWhat, element->previous, element);
/*
* Since the listCreateElement function takes care of linking the nodes
* this is all we have to do here.
*
* note: Doing the linking in the listCreateElement, makes it more clear.
*/
element = element->next;
}
return NULL;
}
/* you should also add a free function, since you allocated the structs using malloc */
void freeList(struct list *list)
{
struct list *current;
current = list;
while (current != NULL)
{
struct list *next;
next = current->next;
free(current);
current = next;
}
}
int main(int argc, char **argv)
{
struct list *element;
element = listCreateElement(0, NULL, NULL);
element = listAddBefore(element, 1, 0);
element = listAddBefore(element, 2, 1);
element = listAddBefore(element, 3, 2);
/* do something with the list */
/* free the allocated memory */
freeList(element);
return 0;
}