Memory leak linked list - c

Question

I'm having issue with an assignment for my CS class. I've been working with a friend, and we've identified that our code has a memory leak, but we can't find what the problem is. Essentially, the code is supposed to create a linked list with digits from 2-1000. Then, the code uses deletemultiples in order to delete numbers that aren't prime. It does this by taking a number and deleting any multiples of that number in the linked list. When we used valgrind, it returned a memory leak.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
struct node{
int info;
struct node *next;
};
typedef struct node node;
node *inserthead(node *head, int a);
node *inserttail(node *head, int a);
node *deletemultiples(node *head, int a);
void printlist(node *head);
void freelist(node *head);
int main(){
node *head1 = NULL;
int i,j;
for(i = 2;i <= 1000;i++)
head1 = inserttail(head1,i);
for(i = 2; i <= 32; i++){
head1 = deletemultiples(head1,i);
}
printlist(head1);
freelist(head1);
}
node *inserthead(node *head, int a){
node *ptr;
ptr = (node*)malloc(sizeof(node));
ptr->info = a;
ptr->next = head;
return(ptr);
}
node *inserttail(node *head, int a){
node *ptr;
node *ptr2 = head;
ptr = (node*)malloc(sizeof(node));
ptr->info = a;
ptr->next = NULL;
if(head == NULL)
return(ptr);
else if (head->next == NULL){
head->next = ptr;
return(head);
}
while(head->next != NULL)
head = head->next;
head->next = ptr;
return(ptr2);
}
void printlist(node *head){
while(head!=NULL){
printf("%i ",head->info);
head = head->next;
}
printf("\n");
}
void freelist(node *head){
node *ptr = head;
while(head != NULL){
head = head->next;
free(ptr);
ptr = head;
}
}
node *deletemultiples(node *head, int a){
node *ptr = head, *temp = head;
while (ptr != NULL) {
if(ptr->info % a > 0){
ptr = ptr->next;
temp = temp->next;
}
else{
ptr = ptr->next;
temp->next = ptr;
}
}
return(head);
}
If anyone can help us figure out what we did wrong, it would be greatly appreciated!

Answer 1

Your deletemultiples() function never frees the nodes it unlinks, so freelist() never reaches them when it walks the list to delete it. Delete the nodes you remove the same way you did in freelist().
Alternatively, you could create an array of 1,000 nodes (It’s a good habit to turn constants like that into symbolic names.) and link and unlink nodes within that array as weak references. You would free the entire array in a single call when you destroy all lists that depend on it.
Kudos for looking for memory leaks in your code. It’ll save you a lot of grief.