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 <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

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.