Level of a Node in Binary Tree

Averages of Levels in Binary Tree

Last Updated : 30 Jan, 2023

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

Level of a Node in Binary Tree

GeeksforGeeks

Improve

Article Tags :

Practice Tags :

Similar Reads

Level of a Node in Binary Tree

Given a Binary Tree and a key, the task is to find the level of key in the Binary Tree. Examples: Input : key = 4 Output: 3Explanation: The level of the key in above binary tree is 3.Input : key = 10 Output: -1Explanation: Key is not present in the above Binary tree. Table of Content [Expected Appro

Print Levels of all nodes in a Binary Tree

Given a Binary Tree and a key, write a function that prints levels of all keys in given binary tree. For example, consider the following tree. If the input key is 3, then your function should return 1. If the input key is 4, then your function should return 3. And for key which is not present in key

Sum of all nodes in a binary tree

Give an algorithm for finding the sum of all elements in a binary tree. In the above binary tree sum = 106. Recommended PracticeSum of Binary TreeTry It!The idea is to recursively, call left subtree sum, right subtree sum and add their values to current node's data. Implementation: C/C++ Code /* Pro

Odd level sum of given Binary Tree

Given a binary tree, write a function that takes the root node and updates the original tree in such a way every node that is present at an odd level gets updated as the sum of the node's value and its grandparent's value. Examples: Input: Consider a binary tree having values {3, 2, 5, 1, 4, NULL, 7

Sum of all nodes at Kth level in a Binary Tree

Given a binary tree with N nodes and an integer K, the task is to find the sum of all the nodes present at the Kth level. Examples: Input: K = 1 Output: 70 Input: K = 2 Output: 120 Approach: Traverse the Binary Tree using Level Order Traversal and queueDuring traversal, pop each element out of the q

Count Non-Leaf nodes in a Binary Tree

Given a Binary tree, count the total number of non-leaf nodes in the tree Examples: Input : Output :2 Explanation In the above tree only two nodes 1 and 2 are non-leaf nodesRecommended PracticeCount Non-Leaf Nodes in TreeTry It! We recursively traverse the given tree. While traversing, we count non-

Create a tree in level order

Given an array of elements, the task is to insert these elements in level order and construct a tree. Input : arr[] = {10, 20, 30, 40, 50, 60} Output : 10 / \ 20 30 / \ / 40 50 60 The task is to construct a whole tree from a given array. To insert in level order in an already constructed tree, pleas

Find all duplicate levels of given Binary Tree

A binary tree is a tree data structure in which each node has at most two child nodes, referred to as the left and right children. In this question, the task is to find all the duplicate levels of a given binary tree. This problem can be used to identify and resolve any duplicate nodes or values in

Reverse alternate levels of a perfect binary tree

Given a perfect binary tree, your task is to reverse the nodes present at alternate levels. Examples: Input: root = [1, 3, 2] 1 / \ 3 2Output: 1 / \ 2 3Explanation: Nodes at level 2 are reversed. Input: root = [1, 2, 3, 4, 5, 6, 7] 1 / \ 2 3 / \ / \ 4 5 6 7Output: 1 / \ 3 2 / \ / \ 4 5 6 7Explanatio

Find the Level of a Binary Tree with Width K

Given a Binary Tree and an integer K, the task is to find the level of the Binary Tree with width K. If multiple levels exists with width K, print the lowest level. If no such level exists, print -1. The width of a level of a Binary tree is defined as the number of nodes between leftmost and the rig