# Mean of distinct odd fibonacci nodes in a Linked List

• Last Updated : 18 Jun, 2021

Given a singly linked list containing N nodes, the task is to find the mean of all the distinct nodes from the list whose data value is an odd Fibonacci number.

Examples:

Input: LL = 5 -> 21 -> 8 ->12-> 3 -> 13 ->144 -> 6
Output 10.5
Explanation:
Fibonacci Nodes present in the Linked List are {5, 21, 8, 3, 13, 144}
Odd Fibonacci Nodes present in the List are {5, 21, 3, 13}
Count of Odd Fibonacci Nodes is 4
Therefore , Mean of Odd Fibonacci Node Values = (5 + 21 + 3 + 13) / 4 = 10.5

Input: LL = 55 -> 3 -> 91 -> 89  -> 76 -> 233 -> 34 -> 87 -> 5 -> 100
Output:77
Explanation:
Fibonacci Nodes present in the Linked List are {55, 3, 89, 233, 34, 5}
Odd Fibonacci Nodes present in the Linked List are {55, 3, 89, 233, 5}
Count of Odd Fibonacci Nodes is 5
Therefore , Mean of Odd Fibonacci Node Values = (55 + 5 + 3 + 89 + 233) / 5 = 77

Approach:The idea is to use hashing to pre-compute and store all Fibonacci numbers up to the largest element in the linked list.
Follow the steps given below to solve the problem:

1. Initialize two variables, say cnt, sum to store the count of odd Fibonacci nodes and the sum of all odd Fibonacci nodes respectively.
2. Traverse the singly linked list and store the largest element of the linked list, say Max.
3. Create a set, say hashmap to store all the Fibonacci numbers up to Max.
4. Traverse the linked list and check if the current node is an odd and Fibonacci number or not. If found to be true, then increment the value of cnt and add the data value of the current node to sum and remove the node from Hashmap.
5. Finally, print the value of (sum / cnt) as the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``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<

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;``class` `GFG{` `// Structure of a``// singly Linked List``static` `class` `Node``{``  ``// Stores data value``  ``// of a Node``  ``int` `data;` `  ``// Stores pointer``  ``// to next Node``  ``Node next;``};``  ` `static` `Node head;` `// Function to insert a``// node at the beginning``// of the singly Linked List``static` `Node 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;``  ``return` `head_ref;``}` `// Function to find the largest``// element from the linked list``static` `int` `largestElement(Node head_ref)``{``  ``// Stores the largest element``  ``// in the linked list``  ``int` `Max = Integer.MIN_VALUE;` `  ``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``static` `HashSet``       ``createHashMap(``int` `Max)``{   ``  ``// Store all Fibonacci``  ``// numbers up to Max``  ``HashSet hashmap =``          ``new` `HashSet<>();` `  ``// Stores first element of``  ``// Fibonacci number``  ``int` `prev = ``0``;` `  ``// Stores second element of``  ``// Fibonacci number``  ``int` `curr = ``1``;` `  ``// Insert prev into hashmap``  ``hashmap.add(prev);` `  ``// Insert curr into hashmap``  ``hashmap.add(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.add(temp);` `    ``// Update prev``    ``prev = curr;` `    ``// Update curr``    ``curr = temp;``  ``}``  ``return` `hashmap;``}` `// Function to find the mean``// of odd Fibonacci nodes``static` `double` `meanofnodes()``{``  ``// Stores the largest element``  ``// in the linked list``  ``int` `Max = largestElement(head);` `  ``// Stores all fibonacci numbers``  ``// up to Max``  ``HashSet 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) %``2``== ``1``)``    ``{``      ``// if data value of the node``      ``// is present in hashmap``      ``if` `(hashmap.contains(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.remove(curr.data);``      ``}` `    ``}` `    ``// Update curr``    ``curr = curr.next;``  ``}` `  ``// Return the required mean``  ``return` `(sum / cnt);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{  ``  ``// Stores head node of``  ``// the linked list``  ``head = ``null``;` `  ``// Insert all data values``  ``// in the linked list``  ``head = push(head, ``5``);``  ``head = push(head, ``21``);``  ``head = push(head, ``8``);``  ``head = push(head, ``12``);``  ``head = push(head, ``3``);``  ``head = push(head, ``13``);``  ``head = push(head, ``144``);``  ``head = push(head, ``6``);` `  ``System.out.print(meanofnodes());``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to implement``# the above approach`` ` `# Structure of a``# singly Linked List``class` `Node:``    ` `    ``def` `__init__(``self``):``     ` `        ``# Stores data value``        ``# of a Node``        ``self``.data ``=` `0``     ` `        ``# Stores pointer``        ``# to next Node``        ``self``.``next` `=` `None`` ` `# Function to add a node at the``# beginning of the singly Linked List``def` `push( head_ref, new_data):`` ` `    ``# Create a new Node``    ``new_node ``=` `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;``    ` `    ``return` `head_ref`` ` `# Function to find the largest``# element from the linked list``def` `largestElement(head_ref):` `    ``# Stores the largest element``    ``# in the linked list``    ``Max` `=` `-``10000000`` ` `    ``head ``=` `head_ref;`` ` `    ``# Iterate over the linked list``    ``while` `(head !``=` `None``):``     ` `        ``# 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``def` `createHashMap(``Max``):``     ` `    ``# Store all Fibonacci numbers``    ``# up to Max``    ``hashmap ``=` `set``()``     ` `    ``# Stores first element of``    ``# Fibonacci number``    ``prev ``=` `0``;``     ` `    ``# Stores second element of``    ``# Fibonacci number``    ``curr ``=` `1``;``     ` `    ``# Insert prev into hashmap``    ``hashmap.add(prev);``     ` `    ``# Insert curr into hashmap``    ``hashmap.add(curr);`` ` `    ``# Insert all elements of``    ``# Fibonacci numbers up to Max``    ``while` `(curr <``=` `Max``):``         ` `        ``# Stores current fibonacci number``        ``temp ``=` `curr ``+` `prev;``         ` `        ``# Insert temp into hashmap``        ``hashmap.add(temp);``         ` `        ``# Update prev``        ``prev ``=` `curr;``         ` `        ``# Update curr``        ``curr ``=` `temp;``    ` `    ``return` `hashmap;`` ` `# Function to find the mean``# of odd Fibonacci nodes``def` `meanofnodes(head):` `    ``# Stores the largest element``    ``# in the linked list``    ``Max` `=` `largestElement(head);`` ` `    ``# Stores all fibonacci numbers``    ``# up to Max``    ``hashmap ``=` `createHashMap(``Max``);``     ` `    ``# Stores current node``    ``# of linked list``    ``curr ``=` `head;``     ` `    ``# Stores count of``    ``# odd Fibonacci nodes``    ``cnt ``=` `0``;``     ` `    ``# Stores sum of all``    ``# odd fibonacci nodes``    ``sum` `=` `0.0``;``     ` `    ``# Traverse the linked list``    ``while` `(curr !``=` `None``):``     ` `        ``# if the data value of``        ``# current node is an odd number``        ``if` `((curr.data) ``%` `2` `=``=` `1``):``             ` `            ``# if data value of the node``            ``# is present in hashmap``            ``if` `(curr.data ``in` `hashmap):``                 ` `                ``# Update cnt``                ``cnt ``+``=` `1``                 ` `                ``# Update sum``                ``sum` `+``=` `curr.data;``                 ` `                ``# Remove current fibonacci number``                ``# from hashmap so that duplicate``                ``# elements can't be counted``                ``hashmap.remove(curr.data);``         ` `        ``# Update curr``        ``curr ``=` `curr.``next``;`` ` `    ``# Return the required mean``    ``return` `(``sum` `/` `cnt);`` ` `# Driver Code``if` `__name__``=``=``'__main__'``:``    ` `    ``# Stores head node of``    ``# the linked list``    ``head ``=` `None``;``     ` `    ``# Insert all data values``    ``# in the linked list``    ``head ``=` `push(head, ``5``);``    ``head ``=` `push(head, ``21``);``    ``head ``=` `push(head, ``8``);``    ``head ``=` `push(head, ``12``);``    ``head ``=` `push(head, ``3``);``    ``head ``=` `push(head, ``13``);``    ``head ``=` `push(head, ``144``);``    ``head ``=` `push(head, ``6``);``          ` `    ``print``(meanofnodes(head))`` ` `# This code is contributed by rutvik_56`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Structure of a``// singly Linked List``public` `class` `Node``{``  ` `  ``// Stores data value``  ``// of a Node``  ``public` `int` `data;``  ` `  ``// Stores pointer``  ``// to next Node``  ``public` `Node next;``};``  ` `static` `Node head;` `// Function to insert a``// node at the beginning``// of the singly Linked List``static` `Node 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;``  ``return` `head_ref;``}` `// Function to find the largest``// element from the linked list``static` `int` `largestElement(Node head_ref)``{``  ` `  ``// Stores the largest element``  ``// in the linked list``  ``int` `Max = ``int``.MinValue;` `  ``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``static` `HashSet<``int``> createDictionary(``int` `Max)``{  ``  ` `  ``// Store all Fibonacci``  ``// numbers up to Max``  ``HashSet<``int``> hashmap = ``new` `HashSet<``int``>();``  ` `  ``// Stores first element of``  ``// Fibonacci number``  ``int` `prev = 0;` `  ``// Stores second element of``  ``// Fibonacci number``  ``int` `curr = 1;` `  ``// Insert prev into hashmap``  ``hashmap.Add(prev);` `  ``// Insert curr into hashmap``  ``hashmap.Add(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.Add(temp);` `    ``// Update prev``    ``prev = curr;` `    ``// Update curr``    ``curr = temp;``  ``}``  ``return` `hashmap;``}` `// Function to find the mean``// of odd Fibonacci nodes``static` `double` `meanofnodes()``{``  ` `  ``// Stores the largest element``  ``// in the linked list``  ``int` `Max = largestElement(head);` `  ``// Stores all fibonacci numbers``  ``// up to Max``  ``HashSet<``int``> hashmap = createDictionary(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) % 2 == 1)``    ``{``      ` `      ``// if data value of the node``      ``// is present in hashmap``      ``if` `(hashmap.Contains(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.Remove(curr.data);``      ``}` `    ``}` `    ``// Update curr``    ``curr = curr.next;``  ``}` `  ``// Return the required mean``  ``return` `(sum / cnt);``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{  ``  ` `  ``// Stores head node of``  ``// the linked list``  ``head = ``null``;` `  ``// Insert all data values``  ``// in the linked list``  ``head = push(head, 5);``  ``head = push(head, 21);``  ``head = push(head, 8);``  ``head = push(head, 12);``  ``head = push(head, 3);``  ``head = push(head, 13);``  ``head = push(head, 144);``  ``head = push(head, 6);` `  ``Console.Write(meanofnodes());``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output:

`10.5`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up