Delete from double Linked List - c

Question

I'm trying to delete a node from a doubly linked list but I have a problem
and this problem is when the node is the first or in the middle it prints 0 instead and it's not really deleted , but it works well when it's the last node in the list and here is the code:
dList* del(dList*ptr, int x)
{
dList *itr = NULL;
for( itr = ptr; itr != NULL; itr = itr -> next)
{
// if the element is the first in the list
if(itr -> value == x && itr -> prev == NULL)
{
itr -> next -> prev = NULL;
ptr = itr -> next;
free(itr);
}
// if the element is the last in the list
else if(itr -> value == x && itr -> next == NULL)
{
itr -> prev -> next = NULL;
free(itr);
}
// if its in the middle
else if(itr -> value == x){
(itr -> prev) -> next = itr -> next;
(itr -> next) -> prev = itr -> prev;
free(itr);
}
}
return ptr;
}
thanks in advance!

Answer 1

This loop
for( itr = ptr; itr != NULL; itr = itr -> next)
{
// if the element is the first in the list
if(itr -> value == x && itr -> prev == NULL)
{
itr -> next -> prev = NULL;
ptr = itr -> next;
free(itr);
}
// ...
has undefined behavior.
For example in the third expression of the for loop
itr = itr -> next
you are using already deleted pointer
free(itr);
If the list for example has only one node then itr->next is equal to NULL. So again this statement
itr -> next -> prev = NULL;
also invokes undefined behavior.
The function can look much simpler if to pass the head node by reference through pointer to it.
Also a more useful return value is the number of the deleted nodes in the list.
The function definition can look the following way
size_t del( dList **ptr, int value )
{
size_t n = 0;
while ( *ptr != NULL )
{
if ( ( *ptr )->value == value )
{
dList *tmp = *ptr;
*ptr = ( *ptr )->next;
if ( *ptr ) ( *ptr )->prev = tmp->prev;
free( tmp );
++n;
}
else
{
ptr = &( *ptr )->next;
}
}
return n;
}
Here is a demonstrative program.
#include <stdio.h>
#include <stdlib.h>
typedef struct dList
{
int value;
struct dList *prev;
struct dList *next;
} dList;
size_t del( dList **ptr, int value )
{
size_t n = 0;
while ( *ptr != NULL )
{
if ( ( *ptr )->value == value )
{
dList *tmp = *ptr;
*ptr = ( *ptr )->next;
if ( *ptr ) ( *ptr )->prev = tmp->prev;
free( tmp );
++n;
}
else
{
ptr = &( *ptr )->next;
}
}
return n;
}
int push_front( dList **head, int value )
{
dList *new_node = malloc( sizeof( dList ) );
int success = new_node != NULL;
if ( success )
{
new_node->prev = NULL;
new_node->value = value;
new_node->next = *head;
if ( *head ) ( *head )->prev = new_node;
*head = new_node;
}
return success;
}
void out( dList *head )
{
for ( ; head != NULL; head = head->next )
{
printf( "%d --> ", head->value );
}
puts( "NULL" );
}
int main(void)
{
dList *head = NULL;
push_front( &head, 1 );
push_front( &head, 2 );
push_front( &head, 1 );
out( head );
size_t n = del( &head, 1 );
printf( "%zu nodes are deleted.\n", n );
out( head );
n = del( &head, 2 );
printf( "%zu nodes are deleted.\n", n );
out( head );
return 0;
}
Its output is
1 --> 2 --> 1 --> NULL
2 nodes are deleted.
2 --> NULL
1 nodes are deleted.
NULL