Freeing Memory after Linked List Removal - c

Question

I am learning C in my free time. I am familiar with C#, Java, and Python. As an exercise, I wrote a linked list in C. It functions correctly, has error handling, etc.
However, I am trying to fix memory leaks. I know that C does not have automatic garbage collection. So how do I "free" a member of a list after I have removed it? I wrote a function called removeAllList(). The function removes the member from the list successfully, but I know that the memory for that member is still allocated. I have tried using the free([myArgument]) function, but it results in infinite loops. Can you show where I would use the free() function to successfully deallocate memory for the removed member in my code?
#include<stdio.h>
#include<stdlib.h>
struct Member{
int data;
struct Member *next;
};
struct List{
int size;
struct Member *root;
};
struct Member *createMember(int i){
struct Member *new;
new = malloc(sizeof(struct Member));
new->data = i;
new->next = NULL;
return new;
}
struct List *createList(int i){
struct List *new;
new = malloc(sizeof(struct List));
new->root = createMember(i);
new->size = 1;
return new;
}
void printList(struct List *list){
struct Member *current = list->root;
//error handling for empty list
if(list->size < 1){
printf("Error: List is empty");
}
//if list is not empty
else{
printf("List size: %i\nContents: ", list->size);
while(current->next != NULL){
printf("%i, ", current->data);
current = current->next;
}
printf("%i\n", current->data);
}
}
void addList(struct List *list, int i){
struct Member *current = list->root;
while(current->next != NULL){
current = current->next;
}
current->next = createMember(i);
list->size++;
}
void removeAllList(struct List *list, int i){
struct Member *current = list->root;
struct Member *prev = list->root;
if(list->size < 1){
//list is empty, end function now
return;
}
//remove all matching list head
while(current->data == i){
if(list->size <= 1){
list->root = NULL;
list->size--;
//list is empty, end function now
return;
}
else{
list->root = current->next;
current = list->root;
list->size--;
}
}
current = current->next;
//remove all matching list body
while(current->next != NULL && list->size > 1){
if(current->data == i){
prev->next = current->next;
list->size--;
}
prev = current;
current = current->next;
}
//remove all matching list tail
if(current->data == i && list->size > 1){
prev->next = NULL;
list->size--;
}
}
main(){
struct List *myList;
myList = createList(4);
addList(myList, 12);
addList(myList, 9);
addList(myList, 4);
addList(myList, 43);
addList(myList, 4);
printList(myList);
removeAllList(myList, 4);
printList(myList);
}

Answer 1

You shouldn't make things that consume memory NULL. You need to free() them like this: free(mynode->next); but only when you're sure there was a malloc() call before.
In your code, you need to use free(list->root); instead of list->root = NULL; and free(prev->next); instead of prev->next = NULL;