Open In App

# Averages of Levels in Binary Tree

Given a non-empty binary tree, print the average value of the nodes on each level.

Examples:

```Input :
4
/ \
2   9
/ \   \
3   5   7

Output : [4 5.5 5]
The average value of nodes on level 0 is 4,
on level 1 is 5.5, and on level 2 is 5.
Hence, print [4 5.5 5].```

The idea is based on Level order traversal line by line | Set 2 (Using Two Queues)

1. Start by pushing the root node into the queue. Then, remove a node from the front of the queue.
2. For every node removed from the queue, push all its children into a new temporary queue.
3. Keep on popping nodes from the queue and adding these node’ s children to the temporary queue till queue becomes empty.
4. Every time queue becomes empty, it indicates that one level of the tree has been considered.
5. While pushing the nodes into temporary queue, keep a track of the sum of the nodes along with the number of nodes pushed and find out the average of the nodes on each level by making use of these sum and count values.
6. After each level has been considered, again initialize the queue with temporary queue and continue the process till both queues become empty.

Implementation:

## C++

 `// C++ program to find averages of all levels``// in a binary tree.``#include ``using` `namespace` `std;` `/* A binary tree node has data, pointer to``   ``left child and a pointer to right child */``struct` `Node {``    ``int` `val;``    ``struct` `Node* left, *right;``};` `/* Function to print the average value of the``   ``nodes on each level */``void` `averageOfLevels(Node* root)``{``    ``vector<``float``> res;` `    ``// Traversing level by level``    ``queue q;``    ``q.push(root);` `    ``while` `(!q.empty()) {` `        ``// Compute sum of nodes and``        ``// count of nodes in current``        ``// level.``        ``int` `sum = 0, count = 0;``        ``queue temp;``        ``while` `(!q.empty()) {``            ``Node* n = q.front();``            ``q.pop();``            ``sum += n->val;``            ``count++;``            ``if` `(n->left != NULL)``                ``temp.push(n->left);``            ``if` `(n->right != NULL)``                ``temp.push(n->right);``        ``}``        ``q = temp;``        ``cout << (sum * 1.0 / count) << ``" "``;``    ``}``}` `/* Helper function that allocates a``   ``new node with the given data and``   ``NULL left and right pointers. */``Node* newNode(``int` `data)``{``    ``Node* temp = ``new` `Node;``    ``temp->val = data;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}` `// Driver code``int` `main()``{``    ``/* Let us construct a Binary Tree``        ``4``       ``/ \``      ``2   9``     ``/ \   \``    ``3   5   7 */` `    ``Node* root = NULL;``    ``root = newNode(4);``    ``root->left = newNode(2);``    ``root->right = newNode(9);``    ``root->left->left = newNode(3);``    ``root->left->right = newNode(8);``    ``root->right->right = newNode(7);``    ``averageOfLevels(root);``    ``return` `0;``}`

## Java

 `// Java program to find averages of all levels``// in a binary tree.``import` `java.util.*;``class` `GfG {` `/* A binary tree node has data, pointer to``left child and a pointer to right child */``static` `class` `Node {``    ``int` `val;``    ``Node left, right;``}` `/* Function to print the average value of the``nodes on each level */``static` `void` `averageOfLevels(Node root)``{``    ``//vector res;` `    ``// Traversing level by level``    ``Queue q = ``new` `LinkedList ();``    ``q.add(root);``    ``int` `sum = ``0``, count  = ``0``;` `    ``while` `(!q.isEmpty()) {` `        ``// Compute sum of nodes and``        ``// count of nodes in current``        ``// level.``        ``sum = ``0``;``        ``count = ``0``;``        ``Queue temp = ``new` `LinkedList ();``        ``while` `(!q.isEmpty()) {``            ``Node n = q.peek();``            ``q.remove();``            ``sum += n.val;``            ``count++;``            ``if` `(n.left != ``null``)``                ``temp.add(n.left);``            ``if` `(n.right != ``null``)``                ``temp.add(n.right);``        ``}``        ``q = temp;``        ``System.out.print((sum * ``1.0` `/ count) + ``" "``);``    ``}``}` `/* Helper function that allocates a``new node with the given data and``NULL left and right pointers. */``static` `Node newNode(``int` `data)``{``    ``Node temp = ``new` `Node();``    ``temp.val = data;``    ``temp.left = ``null``;``    ``temp.right = ``null``;``    ``return` `temp;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``/* Let us construct a Binary Tree``        ``4``    ``/ \``    ``2 9``    ``/ \ \``    ``3 5 7 */` `    ``Node root = ``null``;``    ``root = newNode(``4``);``    ``root.left = newNode(``2``);``    ``root.right = newNode(``9``);``    ``root.left.left = newNode(``3``);``    ``root.left.right = newNode(``5``);``    ``root.right.right = newNode(``7``);``    ``System.out.println(``"Averages of levels : "``);``    ``System.out.print(``"["``);``    ``averageOfLevels(root);``    ``System.out.println(``"]"``);``}``}`

## Python3

 `# Python3 program to find averages of``# all levels in a binary tree.` `# Importing Queue``from` `queue ``import` `Queue` `# Helper class that allocates a``# new node with the given data and``# None left and right pointers.``class` `newNode:``    ``def` `__init__(``self``, data):``        ``self``.val ``=` `data``        ``self``.left ``=` `self``.right ``=` `None``    ` `# Function to print the average value``# of the nodes on each level``def` `averageOfLevels(root):` `    ``# Traversing level by level``    ``q ``=` `Queue()``    ``q.put(root)``    ``while` `(``not` `q.empty()):` `        ``# Compute Sum of nodes and``        ``# count of nodes in current``        ``# level.``        ``Sum` `=` `0``        ``count ``=` `0``        ``temp ``=` `Queue()``        ``while` `(``not` `q.empty()):``            ``n ``=` `q.queue[``0``]``            ``q.get()``            ``Sum` `+``=` `n.val``            ``count ``+``=` `1``            ``if` `(n.left !``=` `None``):``                ``temp.put(n.left)``            ``if` `(n.right !``=` `None``):``                ``temp.put(n.right)``        ``q ``=` `temp``        ``print``((``Sum` `*` `1.0` `/` `count), end ``=` `" "``)` `# Driver code``if` `__name__ ``=``=` `'__main__'``:` `    ``# Let us construct a Binary Tree``    ``#     4``    ``# / \``    ``# 2 9``    ``# / \ \``    ``# 3 5 7``    ``root ``=` `None``    ``root ``=` `newNode(``4``)``    ``root.left ``=` `newNode(``2``)``    ``root.right ``=` `newNode(``9``)``    ``root.left.left ``=` `newNode(``3``)``    ``root.left.right ``=` `newNode(``8``)``    ``root.right.right ``=` `newNode(``7``)``    ``averageOfLevels(root)` `# This code is contributed by PranchalK`

## C#

 `// C# program to find averages of all levels``// in a binary tree.``using` `System;``using` `System.Collections.Generic;` `class` `GfG``{` `    ``/* A binary tree node has data, pointer to``    ``left child and a pointer to right child */``    ``class` `Node``    ``{``        ``public` `int` `val;``        ``public` `Node left, right;``    ``}` `    ``/* Function to print the average value of the``    ``nodes on each level */``    ``static` `void` `averageOfLevels(Node root)``    ``{``        ``//vector res;` `        ``// Traversing level by level``        ``Queue q = ``new` `Queue ();``        ``q.Enqueue(root);``        ``int` `sum = 0, count = 0;` `        ``while` `((q.Count!=0))``        ``{` `            ``// Compute sum of nodes and``            ``// count of nodes in current``            ``// level.``            ``sum = 0;``            ``count = 0;``            ``Queue temp = ``new` `Queue ();``            ``while` `(q.Count != 0)``            ``{``                ``Node n = q.Peek();``                ``q.Dequeue();``                ``sum += n.val;``                ``count++;``                ``if` `(n.left != ``null``)``                    ``temp.Enqueue(n.left);``                ``if` `(n.right != ``null``)``                    ``temp.Enqueue(n.right);``            ``}``            ``q = temp;``            ``Console.Write((sum * 1.0 / count) + ``" "``);``        ``}``    ``}` `    ``/* Helper function that allocates a``    ``new node with the given data and``    ``NULL left and right pointers. */``    ``static` `Node newNode(``int` `data)``    ``{``        ``Node temp = ``new` `Node();``        ``temp.val = data;``        ``temp.left = ``null``;``        ``temp.right = ``null``;``        ``return` `temp;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``/* Let us construct a Binary Tree``            ``4``        ``/ \``        ``2 9``        ``/ \ \``        ``3 5 7 */` `        ``Node root = ``null``;``        ``root = newNode(4);``        ``root.left = newNode(2);``        ``root.right = newNode(9);``        ``root.left.left = newNode(3);``        ``root.left.right = newNode(5);``        ``root.right.right = newNode(7);``        ``Console.WriteLine(``"Averages of levels : "``);``        ``Console.Write(``"["``);``        ``averageOfLevels(root);``        ``Console.WriteLine(``"]"``);``    ``}``}` `// This code has been contributed by``// 29AjayKumar`

## Javascript

 ``

Output

`4 5.5 6 `

Complexity Analysis:

• Time complexity : O(n).
The whole tree is traversed atmost once. Here, n refers to the number of nodes in the given binary tree.
• Auxiliary Space : O(n).
The size of queues can grow upto atmost the maximum number of nodes at any level in the given binary tree. Here, n refers to the maximum number of nodes at any level in the input tree.

Another Approach using the Map

Follow the below steps to solve the problem:

• Create a map to store the {sum for each level, number of elements in each level}
• Now recursively traverse the entire tree, while tracking the height of the tree
• For every level, keep tracking the sum as well as the number of elements in that level
• Once the entire tree is traversed, the map will contain sum of all the levels and the number of elements in each level
• Traverse the map
• Divide the sum by the number of elements
• Print the answers for every level

Below is the implementation of the above approach:

## C++

 `// C++ code for the above approach` `#include ``using` `namespace` `std;` `// A binary tree node has data, pointer to``// left child and a pointer to right child``struct` `Node {``    ``int` `val;``    ``struct` `Node *left, *right;``};` `// Initialising a map with key as levels of the tree``map<``int``, pair<``double``, ``double``> > mp;` `void` `avg(Node* r, ``int` `l)``{``    ``// If the node is NULL``    ``if` `(r == NULL)``        ``return``;` `    ``// Add the current value to the sum of this level``    ``mp[l].first += r->val;` `    ``// Increase the number of elements in the current level``    ``mp[l].second++;` `    ``// Traverse left``    ``avg(r->left, l + 1);` `    ``// Traverse right``    ``avg(r->right, l + 1);``}``void` `averageOfLevels(Node* root)``{` `    ``avg(root, 0);` `    ``// Travaersing for levels in map``    ``for` `(``auto` `i : mp) {``        ``// Printing average of all levels``        ``cout << (i.second.first / i.second.second) << ``' '``;``    ``}``}` `// Function to create a new node``Node* newNode(``int` `data)``{``    ``Node* temp = ``new` `Node;``    ``temp->val = data;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}``int` `main()``{``    ``/* Let us construct a Binary Tree``        ``4``       ``/ \``      ``2   9``     ``/ \   \``    ``3   5   7 */` `    ``Node* root = NULL;``    ``root = newNode(4);``    ``root->left = newNode(2);``    ``root->right = newNode(9);``    ``root->left->left = newNode(3);``    ``root->left->right = newNode(8);``    ``root->right->right = newNode(7);` `    ``// Function Call``    ``averageOfLevels(root);``}``// This Code has been contributed by Alok Khansali`

## Java

 `// Java program for above approach A binary tree node has``// data, pointer to left child and a pointer to right child``import` `java.io.*;``import` `java.util.*;` `// A binary tree node has data, pointer to left child and a``// pointer to right child``class` `Node {``  ``int` `val;``  ``Node left;``  ``Node right;` `  ``Node(``int` `val)``  ``{``    ``this``.val = val;``    ``left = ``null``;``    ``right = ``null``;``  ``}``}` `class` `GFG {` `  ``// Initialising a map with key as levels of the tree``  ``Map mp = ``new` `HashMap<>();` `  ``// Function to calculate the average of the levels``  ``public` `void` `avg(Node r, ``int` `l)``  ``{``    ``// If the node is NULL``    ``if` `(r == ``null``)``      ``return``;` `    ``// Add the current value to the sum of this level``    ``if` `(!mp.containsKey(l)) {``      ``mp.put(l, ``new` `Double[] { (``double``)r.val, ``1.0` `});``    ``}``    ``else` `{``      ``Double[] temp = mp.get(l);``      ``temp[``0``] += r.val;``      ``temp[``1``] += ``1``;``      ``mp.put(l, temp);``    ``}` `    ``// Traverse left``    ``avg(r.left, l + ``1``);` `    ``// Traverse right``    ``avg(r.right, l + ``1``);``  ``}` `  ``// Function to call the avg function and print the``  ``// averages``  ``public` `void` `averageOfLevels(Node root)``  ``{``    ``avg(root, ``0``);``    ``// Travaersing for levels in map``    ``for` `(Map.Entry entry :``         ``mp.entrySet()) {``      ``// Printing average of all levels``      ``System.out.print(entry.getValue()[``0``]``                       ``/ entry.getValue()[``1``]``                       ``+ ``" "``);``    ``}``  ``}` `  ``public` `static` `void` `main(String[] args)``  ``{``    ``/* Let us construct a Binary Tree``            ``4``           ``/ \``          ``2   9``         ``/ \   \``        ``3   5   7 */``    ``Node root = ``null``;``    ``root = ``new` `Node(``4``);``    ``root.left = ``new` `Node(``2``);``    ``root.right = ``new` `Node(``9``);``    ``root.left.left = ``new` `Node(``3``);``    ``root.left.right = ``new` `Node(``8``);``    ``root.right.right = ``new` `Node(``7``);` `    ``GFG bt = ``new` `GFG();``    ``bt.averageOfLevels(root);``  ``}``}` `// This code is contributed by lokeshmvs21.`

## Python3

 `# Python program for the above approach``# A binary tree node has data, pointer to``# left child and a pointer to right child``class` `Node:``    ``def` `__init__(``self``, data):``        ``self``.val ``=` `data``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `class` `Pair:``    ``def` `__init__(``self``, val1, val2):``        ``self``.first ``=` `val1``        ``self``.second ``=` `val2` `# Initialising a dictionary with key as levels of the tree``mp ``=` `{}` `def` `avg(r, l):``    ``# if the node is null``    ``if` `r ``is` `None``:``        ``return``    ` `    ``# Add the current value to the sum of this level``    ``# Increase the number of elements in the current level``    ``if` `l ``in` `mp:``        ``mp[l] ``=` `Pair(mp[l].first ``+` `r.val, mp[l].second)``        ``mp[l].second ``+``=` `1``    ``else``:``        ``mp[l] ``=` `Pair(r.val, ``1``)``    ` `    ``# Traverse left``    ``avg(r.left, l``+``1``)``    ` `    ``# Traverse right``    ``avg(r.right, l``+``1``)` `def` `average_of_levels(root):``    ``avg(root, ``0``)``    ` `    ``# Traversing for levels in dictionary``    ``for` `key ``in` `mp:``    ` `        ``# printing average of all levels``        ``print``(mp[key].first ``/` `mp[key].second)` `# function to create a new node``def` `new_node(data):``    ``temp ``=` `Node(data)``    ``return` `temp` `# Let us construct a Binary Tree``#        4``#       / \``#      2   9``#     / \   \``#    3   8   7``root ``=``None``root ``=` `new_node(``4``)``root.left ``=` `new_node(``2``)``root.right ``=` `new_node(``9``)``root.left.left ``=` `new_node(``3``)``root.left.right ``=` `new_node(``8``)``root.right.right ``=` `new_node(``7``)``average_of_levels(root)` `# This code is contributed by lokeshpotta20.`

## C#

 `using` `System;``using` `System.Collections.Generic;` `// A binary tree node has data, pointer to``// left child and a pointer to right child``class` `Node``{``    ``public` `int` `val;``    ``public` `Node left;``    ``public` `Node right;``    ``public` `Node(``int` `val)``    ``{``        ``this``.val = val;``        ``left = ``null``;``        ``right = ``null``;``    ``}``}``class` `BinaryTree``{``    ``// Initialising a map with key as levels of the tree``    ``public` `Dictionary<``int``, Tuple<``double``,``           ``double``>> mp = ``new` `Dictionary<``int``, Tuple<``double``, ``double``>>();``    ` `    ``// Function to calculate the average of the levels``    ``public` `void` `avg(Node r, ``int` `l)``    ``{``        ``// If the node is NULL``        ``if` `(r == ``null``) ``return``;` `        ``// Add the current value to the sum of this level``        ``mp[l] = Tuple.Create(mp.ContainsKey(l) ? mp[l].Item1 + r.val :``                             ``r.val, mp.ContainsKey(l) ? mp[l].Item2 + 1 : 1);` `        ``// Traverse left``        ``avg(r.left, l + 1);` `        ``// Traverse right``        ``avg(r.right, l + 1);``    ``}` `    ``// Function to call the avg function and print the averages``    ``public` `void` `averageOfLevels(Node root)``    ``{``        ``avg(root, 0);``        ``// Travaersing for levels in map``        ``foreach` `(``var` `i ``in` `mp)``        ``{``            ``// Printing average of all levels``            ``Console.Write((i.Value.Item1 / i.Value.Item2) + ``" "``);``        ``}``    ``}``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``/* Let us construct a Binary Tree``            ``4``           ``/ \``          ``2   9``         ``/ \   \``        ``3   5   7 */` `        ``Node root = ``null``;``        ``root = ``new` `Node(4);``        ``root.left = ``new` `Node(2);``        ``root.right = ``new` `Node(9);``        ``root.left.left = ``new` `Node(3);``        ``root.left.right = ``new` `Node(8);``        ``root.right.right = ``new` `Node(7);` `        ``BinaryTree bt = ``new` `BinaryTree();``        ``bt.averageOfLevels(root);``    ``}``}`

## Javascript

 `// JavaScript program for above approach``// A binary tree node has data, pointer to``// left child and a pointer to right child``class Node{``    ``constructor(data){``        ``this``.val = data;``        ``this``.left = ``null``;``        ``this``.right = ``null``;``    ``}``}` `class pair{``    ``constructor(val1, val2){``        ``this``.first = val1;``        ``this``.second = val2;``    ``}``}` `// Initialising a map with key as levels of the tree``let mp = ``new` `Map();` `function` `avg(r, l){``    ``// if the node is null``    ``if``(r == ``null``) ``return``;``    ` `    ``// Add the current value to the sum of this level``    ``// Increase the number of elements in the current level``    ``if``(mp.has(l)){``        ``mp.set(l, ``new` `pair(mp.get(l).first + r.val, mp.get(l).second));``        ``mp.get(l).second += 1;``    ``}``    ``else``        ``mp.set(l, ``new` `pair(r.val, 1));``    ` `    ` `    ``// Traverse left``    ``avg(r.left, l+1);``    ` `    ``// Traverse right``    ``avg(r.right, l+1);``}` `function` `averageOfLevels(root){``    ``avg(root, 0);``    ` `    ``// Traversing for levels in map``    ``mp.forEach(``function``(value, key)``    ``{``    ` `        ``// printing average of all levels``        ``console.log(value.first / value.second + ``" "``);``    ``})``}` `// function to create a new node``function` `newNode(data){``    ``let temp = ``new` `Node(data);``    ``return` `temp;``}` `/* Let us construct a Binary Tree``    ``4``   ``/ \``  ``2   9`` ``/ \   \``3   5   7 */` `let root = ``null``;``root = newNode(4);``root.left = newNode(2);``root.right = newNode(9);``root.left.left = newNode(3);``root.left.right = newNode(8);``root.right.right = newNode(7);` `// Function call``averageOfLevels(root);` `// This code is contributed by Yash Agarwal(yashagarwal2852002)`

Output

`4 5.5 6 `

Time Complexity: O(N*log(N)), for storing the level wise sum in map.
Auxiliary Space: O(H), H = Height of the tree

This article is contributed by Aakash Pal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.