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)
- Start by pushing the root node into the queue. Then, remove a node from the front of the queue.
- For every node removed from the queue, push all its children into a new temporary queue.
- Keep on popping nodes from the queue and adding these node’ s children to the temporary queue till queue becomes empty.
- Every time queue becomes empty, it indicates that one level of the tree has been considered.
- 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.
- 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 <bits/stdc++.h> 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<Node*> q;
q.push(root);
while (!q.empty()) {
// Compute sum of nodes and
// count of nodes in current
// level.
int sum = 0, count = 0;
queue<Node*> 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<float> res;
// Traversing level by level
Queue<Node> q = new LinkedList<Node> ();
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<Node> temp = new LinkedList<Node> ();
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<float> res;
// Traversing level by level
Queue<Node> q = new Queue<Node> ();
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<Node> temp = new Queue<Node> ();
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
<script> // Javascript program to find averages of // all levels in a binary tree. class Node { constructor(data)
{
this .left = null ;
this .right = null ;
this .val = data;
}
} // Function to print the average value // of the nodes on each level function averageOfLevels(root)
{ // Traversing level by level
let q = [];
q.push(root);
let sum = 0, count = 0;
while (q.length > 0)
{
// Compute sum of nodes and
// count of nodes in current
// level.
sum = 0;
count = 0;
let temp = [];
while (q.length > 0)
{
let n = q[0];
q.shift();
sum += n.val;
count++;
if (n.left != null )
temp.push(n.left);
if (n.right != null )
temp.push(n.right);
}
q = temp;
document.write((sum * 1.0 / count) + " " );
}
} // Helper function that allocates a // new node with the given data and // NULL left and right pointers. function newNode(data)
{ let temp = new Node(data);
return temp;
} // Driver code /* 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(5); root.right.right = newNode(7); document.write( "Averages of levels : " + "</br>" );
document.write( "[" );
averageOfLevels(root); document.write( "]" + "</br>" );
// This code is contributed by divyeshrabadiya07 </script> |
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 <bits/stdc++.h> 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<Integer, Double[]> 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<Integer, Double[]> 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