Mean of distinct odd fibonacci nodes in a Linked List

// C++ program to implement
// the above approach

#include <bits/stdc++.h>
using namespace std;

// Structure of a
// singly Linked List
struct Node {
    
    // Stores data value
    // of a Node
    int data;
    
    // Stores pointer 
    // to next Node
    Node* next;
};

// Function to insert a node at the
// beginning of the singly Linked List
void push(Node** head_ref, int new_data)
{

    // Create a new Node
    Node* new_node = new Node;

    // Insert the data into 
    // the Node
    new_node->data = new_data;
    
    // Insert pointer to
    // the next Node
    new_node->next = (*head_ref);

    // Update head_ref
    (*head_ref) = new_node;
}

// Function to find the largest
// element from the linked list
int largestElement(struct Node* head_ref)
{
    // Stores the largest element 
    // in the linked list
    int Max = INT_MIN;

    Node* head = head_ref;

    // Iterate over the linked list
    while (head != NULL) {
    
        // If max is less than
        // head->data
        if (Max < head->data) {
        
            // Update  max
            Max = head->data;
        }
        
        // Update head
        head = head->next;
    }
    return Max;
}

// Function to store all Fibonacci numbers 
// up to the largest element of the list
set<int> createHashMap(int Max)
{
    
    // Store all Fibonacci numbers
    // up to Max
    set<int> hashmap;
    
    
    // Stores first element of 
    // Fibonacci number
    int prev = 0;
    
    // Stores second element of
    // Fibonacci number
    int curr = 1;
    
    // Insert prev into hashmap
    hashmap.insert(prev);
    
    // Insert curr into hashmap
    hashmap.insert(curr);

    // Insert all elements of
    // Fibonacci numbers up to Max
    while (curr <= Max) {
        
        // Stores current fibonacci number
        int temp = curr + prev;
        
        // Insert temp into hashmap
        hashmap.insert(temp);
        
        // Update prev
        prev = curr;
        
        // Update curr
        curr = temp;
    }
    return hashmap;
}

// Function to find the mean
// of odd Fibonacci nodes
double meanofnodes(struct Node* head)
{
    // Stores the largest element 
    // in the linked list
    int Max = largestElement(head);

    // Stores all fibonacci numbers 
    // up to Max
    set<int> hashmap 
           = createHashMap(Max);
    
    // Stores current node
    // of linked list
    Node* curr = head;
    
    // Stores count of
    // odd Fibonacci nodes
    int cnt = 0;
    
    // Stores sum of all 
    // odd fibonacci nodes
    double sum = 0.0;
    
    // Traverse the linked list
    while (curr != NULL) {
    
        // if the data value of 
        // current node is an odd number
        if ((curr->data) & 1){
            
            // if data value of the node
            // is present in hashmap
            if (hashmap.count(curr->data)) {
                
                // Update cnt
                cnt++;
                
                // Update sum
                sum += curr->data;
                
                // Remove current fibonacci number
                // from hashmap so that duplicate
                // elements can't be counted
                hashmap.erase(curr->data);
            }
            
        }
        
        // Update curr
        curr = curr->next;
    }

    // Return the required mean
    return (sum / cnt);
}

// Driver Code
int main()
{   
    // Stores head node of
    // the linked list
    Node* head = NULL;
    
    // Insert all data values 
    // in the linked list
    push(&head, 5);
    push(&head, 21);
    push(&head, 8);
    push(&head, 12);
    push(&head, 3);
    push(&head, 13);
    push(&head, 144);
    push(&head, 6);
    
    
    cout<<meanofnodes(head);

    return 0;
}