Count minimum frequency elements in a linked list

// C Program
// Count minimum frequency elements in a linked list
#include <stdio.h>
 //For malloc function
#include <stdlib.h>

//Linked List Node
struct Node
{
    int data;
    struct Node *next;
};
//Frequency node counter
struct NodeCounter
{
    int data;
    int frequency;
    struct NodeCounter *next;
};
//Create a node of linked list
struct Node *create_node(int data)
{
    //Create dynamic node
    struct Node *node = (struct Node *) malloc(sizeof(struct Node));
    if (node == NULL)
    {
        printf("Memory overflow\n");
    }
    else
    {
        //Set initial node value
        node->data = data;
        node->next = NULL;
    }
    return node;
}
//Add new node at end of linked list 
void insert(struct Node **head, int data)
{
    struct Node *node = create_node(data);
    if ( *head == NULL)
    {
        *head = node;
    }
    else
    {
        struct Node *temp = *head;
        //Find last node
        while (temp->next != NULL)
        {
            temp = temp->next;
        }
        //Add node at last possition
        temp->next = node;
    }
}
//Display linked list element
void display(struct Node *head)
{
    if (head == NULL)
    {
        printf("\nEmpty linked list\n");
        return;
    }
    struct Node *temp = head;
    printf("\n Linked List : ");
    //iterating linked list elements
    while (temp != NULL)
    {
        printf("  %d", temp->data);
        //visit to next node
        temp = temp->next;
    }
    printf("\n");
}
//Create a new node of NodeCounter
struct NodeCounter *make_counter(int data)
{
    //Create dynamic node of node counter
    struct NodeCounter *node = (struct NodeCounter *) malloc(sizeof(struct NodeCounter));
    if (node == NULL)
    {
        printf("Memory overflow\n");
    }
    else
    {
        //Set initial node value
        node->data = data;
        //Set the initial node frequency
        node->frequency = 1;
        node->next = NULL;
    }
    return node;
}
//Find node of given key in auxiliary list
struct NodeCounter *find_node(struct NodeCounter *front, int key)
{
    struct NodeCounter *temp = front;
    while (temp != NULL)
    {
        if (temp->data == key)
        {
            //When key node exist
            return temp;
        }
        //visit to next node
        temp = temp->next;
    }
    //when key not exist
    return NULL;
}
//Count all nodes which containing of minimum frequency
void min_frequency_node(struct Node *head)
{
    if (head == NULL)
    {
        return;
    }
    //Display of linked list nodes
    display(head);
    //Define some auxiliary variables
    struct NodeCounter *front = NULL;
    struct NodeCounter *tail = NULL;
    struct NodeCounter *current = NULL;
    struct NodeCounter *temp = NULL;
    //Resultant variables
    int counter = 1;
    //Get list1 node of linked list
    struct Node *auxiliary = head;
    //Create auxiliary list which is contain data and element occurrence
    while (auxiliary != NULL)
    {
        //Find auxiliary node value in resultant list
        current = find_node(front, auxiliary->data);
        if (current != NULL)
        {
            //update node frequency
            current->frequency = current->frequency + 1;
        }
        else
        {
            //create new node of auxiliary list
            current = make_counter(auxiliary->data);
            if (front == NULL)
            {
                //list1 node of auxiliary list
                front = current;
            }
            else
            {
                //add new node at end of auxiliary list
                tail->next = current;
            }
            tail = current;
        }
        //visit to next node
        auxiliary = auxiliary->next;
    }
    //Start to list1 node
    temp = front;
    current = front;
    //Find minimum frequency
    while (temp != NULL)
    {
        if (current->data > temp->data)
        {
            //Get node of minimum frequency
            current = temp;
        }
        //visit to next node
        temp = temp->next;
    }
    if (current == NULL)
    {
        //When auxiliary list are empty
        printf(" None ");
    }
    else
    {
        //Display the value of resultant minimum frequency
        printf(" Result Minimum Frequency : %d \n Nodes : [", current->frequency);
        //reset value
        counter = 0;
        tail = NULL;
        //Count nodes which is contain minimum frequency
        while (front != NULL)
        {
            //Get current node
            temp = front;
            if (front->frequency == current->frequency)
            {
                //print node of which is contain minimum frequency
                printf(" %d", front->data);
                //count minimum frequency element 
                counter++;
            }
            //visit to next node
            front = front->next;
            //free node
            free(temp);
            temp = NULL;
        }
        //Display result
        printf(" ]\n Result : %d \n", counter);
    }
    printf("\n");
}
int main()
{
    struct Node *list1 = NULL;
    //Create first linked list
    insert( &list1, 2);
    insert( &list1, 4);
    insert( &list1, 7);
    insert( &list1, 5);
    insert( &list1, 7);
    insert( &list1, 7);
    insert( &list1, 4);
    insert( &list1, 1);
    insert( &list1, 5);
    insert( &list1, 3);
    insert( &list1, 1);
    insert( &list1, 2);
    insert( &list1, 4);
    min_frequency_node(list1);
    struct Node *list2 = NULL;
    //Create second linked list
    insert( &list2, 9);
    insert( &list2, 5);
    insert( &list2, 7);
    insert( &list2, 4);
    insert( &list2, 7);
    insert( &list2, 7);
    insert( &list2, 5);
    min_frequency_node(list2);
    return 0;
}

Output

 Linked List :   2  4  7  5  7  7  4  1  5  3  1  2  4
 Result Minimum Frequency : 2
 Nodes : [ 2 5 1 ]
 Result : 3


 Linked List :   9  5  7  4  7  7  5
 Result Minimum Frequency : 1
 Nodes : [ 9 4 ]
 Result : 2