Remove multiple strings based on the given substring - c

Question

I'm trying to create a code where there are the names (e.g. Andy, Barry, Matilda) and the names will be removed when I enter a certain substring (e.g. substring is y, therefore Andy and Barry will be removed. The only one left is Matilda). Can anyone offer me assistance?
My code is:
void del(char key[])
{
if(head == NULL)
{
printf("There's no data\n");
}
else{
curr = head;
while(curr != NULL && strcmp(curr->name, key) != 0)
{
curr = curr->next;
}
if(curr == NULL)
{
printf("Node is not in the list\n");
}
if(curr == head & curr == tail)
{
free(curr);
head = tail = NULL;
}
else if(curr == head)
{
head = head->next;
free(curr);
head->prev = NULL;
}
else if(curr == tail)
{
tail = tail->prev;
free(curr);
tail->next = NULL;
}
else
{
curr->prev->next = curr->next;
curr->next->prev = curr->prev;
free(curr);
}
}
}

Answer 1

Your code correctly removes a single list node, except when key is not found - in this case, a return after printf("Node is not in the list\n"); is missing.
To remove multiple nodes, we have to loop over the list, continuing also if a match is found and deleted. To print the message Node is not in the list only if nothing was found, we can use a flag which is tested after the loop. So, you can replace the content of your outer else block e. g. with
void *next;
int deleted = 0;
for (curr = head; curr; curr = next)
{ next = curr->next;
if (strstr(curr->name, key))
{ deleted = 1;
// the rest of this block is your code unchanged
if(curr == head & curr == tail)
{
free(curr);
head = tail = NULL;
}
else if(curr == head)
{
head = head->next;
free(curr);
head->prev = NULL;
}
else if(curr == tail)
{
tail = tail->prev;
free(curr);
tail->next = NULL;
}
else
{
curr->prev->next = curr->next;
curr->next->prev = curr->prev;
free(curr);
}
}
}
if (!deleted) printf("Node is not in the list\n");

Answer 2

You have not offered a lot of information to go on, but I take that is being new to the community. From what you do provide, it is clear that, at minimum, you have a Doubly-Linked-List where you have a string as the data member. It is also clear that you have declared both the head and tail pointer as global variables (not a great practice, as you should pass any information required by your function as a parameter, but for this learning exercise it provides minimal simplification)
From what you describe you want your del function to do, you want to iterate over your linked-list testing whether the name member contains the substring key and if so, you want to delete that node from your list.
You have two primary problems:
you use the wrong string function to check for a substring in your name member. strcmp() will only find the nodes where the complete name matches your key. Instead you want strstr() where you can match key anywhere within name;
you over-complicate the node deletion by attempting to use a pointer to the current node alone to iterate over the list, instead of using both a pointer and the address for the current node. See Linus on Understanding Pointers
To correct your fist problem, you simply need to change strcmp() to strstr() fot match key anywhere in name, e.g.
...
if (strstr(curr->name, key) != NULL) { /* strstr, not strcmp, to find key */
...
To solve the second problem, you need to rework your del function. To do so, you have to understand how iterating while removing multiple-nodes differs from iterating to find a single-node to delete. When looping to find a single-node to delete, you simply advance to the next node in your list on each iteration until the node is found and then you delete that node.
You cannot do that when potentially deleting multiple nodes from your list. Why? When you delete a node with a matching substring, the next node in the list takes its place. You can't just advance to the next node after this deletion because the node that is now the current node after you delete the first may also contain the substring you want to find. If you just blindly advance to the next node and the current after deletion also contains the substring, you will skip over deleting that node.
What this means from a code standpoint is you need to add an else clause below your if, e.g.
if (strstr(curr->name, key) != NULL) { /* strstr, not strcmp, to find key */
...
else
...
Under your if clause, the next node replaces the current after deletion, so you do NOT advance again to the next node in your list. That way the new current node will be checked for the matching substring on the next iteration. You only advance to the next node under your else clause if key does not match.
When iterating with both a pointer to the current node along with the address of the current node, you do not have to handle special cases. You will always set the content at the current address to the next node in your list. (head doesn't change, because you have set the struct at that address to the next on deletion) The only check you need is to check if you are deleting the tail node. In that case you need to update the tail node to point to the previous node as you will be deleting what tail currently points to. Otherwise, all you need to do is update the ->prev pointer of the node you moved into the current address to point to the previous node in the list.
With that in mind, your del function reduces to:
void del (char key[])
{
if (head == NULL) { /* check empty */
puts ("list-empty");
return;
}
node_t **ppnode = &head, /* address of current node */
*curr = head; /* pointer to current node */
while (curr) {
if (strstr(curr->name, key) != NULL) { /* strstr, not strcmp, to find key */
*ppnode = curr->next; /* fill address w/next node */
if (curr != tail) /* if not tail */
(*ppnode)->prev = curr->prev; /* set ->prev to prev node */
else /* otherwise */
tail = curr->prev; /* update tail pointer */
free (curr); /* free node */
curr = *ppnode; /* set new current node */
}
else { /* node to keep */
ppnode = &curr->next; /* set address to addres of next */
curr = curr->next; /* advance to next node */
}
}
}
Without knowing more about your code, all we can do is write a short example that adds your strings as nodes in a list (using a fixed name to simplify things). A short example like:
int main (void) {
add ("Andy"); /* add nodes to list */
add ("Barry");
add ("Matilda");
prnfwd(); /* print forward and reverse */
prnrev();
putchar ('\n');
del ("y"); /* delete nodes containing substring "y" */
prnfwd(); /* print forward and reverse */
prnrev();
del_list(); /* free allocated memory */
}
That adds the nodes, iterates over the list in both directions, calls del ("y"); to delete all nodes where the string contains the substring "y" (note that is different from the character 'y'), and then iterates over the list again in both direction outputting what remains before freeing all memory in the list.
Example Use/Output
The result given your example strings would be:
$ ./bin/lldglobaldelkey
Andy Barry Matilda
Matilda Barry Andy
Matilda
Matilda
The full implementation of the example is:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXNM 64
typedef struct node_t {
char name[MAXNM];
struct node_t *prev, *next;
} node_t;
node_t *head, *tail;
/** add node at end of list, update tail to end */
node_t *add (const char *s)
{
node_t *node = malloc (sizeof *node); /* allocate node */
if (!node) /* validate allocation */
return NULL;
strcpy (node->name, s); /* initialize new node */
node->prev = node->next = NULL;
if (!head) /* if 1st node, node is head/tail */
head = tail = node;
else { /* otherwise */
node->prev = tail; /* set prev to tail */
tail->next = node; /* add at end, update tail pointer */
tail = node;
}
return node; /* return new node */
}
/* print list forward */
void prnfwd (void)
{
if (!head) { /* check empty */
puts ("list-empty");
return;
}
for (node_t *n = head; n; n = n->next) /* iterate over nodes - forward */
printf (" %s", n->name);
putchar ('\n');
}
/* print list reverse */
void prnrev (void)
{
if (!head) { /* check empty */
puts ("list-empty");
return;
}
for (node_t *n = tail; n; n = n->prev) /* iterate over nodes - reverse */
printf (" %s", n->name);
putchar ('\n');
}
/** delete all nodes in list */
void del_list (void)
{
node_t *n = head;
if (!head) { /* check empty */
puts ("list-empty");
return;
}
while (n) { /* iterate over nodes - forward */
node_t *victim = n; /* save ptr to node to delete */
n = n->next; /* advance to next */
free (victim); /* delete node */
}
head = tail = NULL; /* set pointers NULL */
}
void del (char key[])
{
if (head == NULL) { /* check empty */
puts ("list-empty");
return;
}
node_t **ppnode = &head, /* address of current node */
*curr = head; /* pointer to current node */
while (curr) {
if (strstr(curr->name, key) != NULL) { /* strstr, not strcmp, to find key */
*ppnode = curr->next; /* fill address w/next node */
if (curr != tail) /* if not tail */
(*ppnode)->prev = curr->prev; /* set ->prev to prev node */
else /* otherwise */
tail = curr->prev; /* update tail pointer */
free (curr); /* free node */
curr = *ppnode; /* set new current node */
}
else { /* node to keep */
ppnode = &curr->next; /* set address to addres of next */
curr = curr->next; /* advance to next node */
}
}
}
int main (void) {
add ("Andy"); /* add nodes to list */
add ("Barry");
add ("Matilda");
prnfwd(); /* print forward and reverse */
prnrev();
putchar ('\n');
del ("y"); /* delete nodes containing substring "y" */
prnfwd(); /* print forward and reverse */
prnrev();
del_list(); /* free allocated memory */
}
Memory Use/Error Check
In any code you write that dynamically allocates memory, you have 2 responsibilities regarding any block of memory allocated: (1) always preserve a pointer to the starting address for the block of memory so, (2) it can be freed when it is no longer needed.
It is imperative that you use a memory error checking program to ensure you do not attempt to access memory or write beyond/outside the bounds of your allocated block, attempt to read or base a conditional jump on an uninitialized value, and finally, to confirm that you free all the memory you have allocated.
For Linux valgrind is the normal choice. There are similar memory checkers for every platform. They are all simple to use, just run your program through it.
$ valgrind ./bin/lldglobaldelkey
==10704== Memcheck, a memory error detector
==10704== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==10704== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==10704== Command: ./bin/lldglobaldelkey
==10704==
Andy Barry Matilda
Matilda Barry Andy
Matilda
Matilda
==10704==
==10704== HEAP SUMMARY:
==10704== in use at exit: 0 bytes in 0 blocks
==10704== total heap usage: 4 allocs, 4 frees, 1,264 bytes allocated
==10704==
==10704== All heap blocks were freed -- no leaks are possible
==10704==
==10704== For counts of detected and suppressed errors, rerun with: -v
==10704== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Always confirm that you have freed all memory you have allocated and that there are no memory errors.
I hope this is close to what your implementation is. Look things over and let me know if you have further questions.