Maximum width of a binary tree

Given a binary tree, write a function to get the maximum width of the given tree. Width of a tree is maximum of widths of all levels.

Let us consider the below example tree.

         1
        /  \
       2    3
     /  \     \
    4    5     8 
              /  \
             6    7

For the above tree,
width of level 1 is 1,
width of level 2 is 2,
width of level 3 is 3
width of level 4 is 2.

So the maximum width of the tree is 3.

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Method 1 (Using Level Order Traversal)
This method mainly involves two functions. One is to count nodes at a given level (getWidth), and other is to get the maximum width of the tree(getMaxWidth). getMaxWidth() makes use of getWidth() to get the width of all levels starting from root.

/*Function to print level order traversal of tree*/
getMaxWidth(tree)
maxWdth = 0
for i = 1 to height(tree)
  width =   getWidth(tree, i);
  if(width > maxWdth) 
      maxWdth  = width
return maxWidth

/*Function to get width of a given level */
getWidth(tree, level)
if tree is NULL then return 0;
if level is 1, then return 1;  
else if level greater than 1, then
    return getWidth(tree->left, level-1) + 
    getWidth(tree->right, level-1);

C

#include <stdio.h> 
#include <stdlib.h> 
  
/* A binary tree node has data, pointer to left child 
   and a pointer to right child */
struct node 
{ 
    int data; 
    struct node* left; 
    struct node* right; 
}; 
  
/*Function protoypes*/
int getWidth(struct node* root, int level); 
int height(struct node* node); 
struct node* newNode(int data); 
  
/* Function to get the maximum width of a binary tree*/
int getMaxWidth(struct node* root) 
{ 
  int maxWidth = 0;    
  int width; 
  int h = height(root); 
  int i; 
    
  /* Get width of each level and compare  
     the width with maximum width so far */
  for(i=1; i<=h; i++) 
  { 
    width = getWidth(root, i); 
    if(width > maxWidth) 
      maxWidth = width; 
  }      
    
  return maxWidth; 
} 
  
/* Get width of a given level */
int getWidth(struct node* root, int level) 
{ 
      
  if(root == NULL) 
    return 0; 
    
  if(level == 1) 
    return 1; 
              
  else if (level > 1) 
    return getWidth(root->left, level-1) +  
             getWidth(root->right, level-1); 
} 
  
  
/* UTILITY FUNCTIONS */
/* Compute the "height" of a tree -- the number of 
    nodes along the longest path from the root node 
    down to the farthest leaf node.*/
int height(struct node* node) 
{ 
   if (node==NULL) 
     return 0; 
   else
   { 
     /* compute the height of each subtree */
     int lHeight = height(node->left); 
     int rHeight = height(node->right); 
     /* use the larger one */
     
     return (lHeight > rHeight)? (lHeight+1): (rHeight+1); 
   } 
} 
/* Helper function that allocates a new node with the 
   given data and NULL left and right pointers. */
struct node* newNode(int data) 
{ 
  struct node* node = (struct node*) 
                       malloc(sizeof(struct node)); 
  node->data = data; 
  node->left = NULL; 
  node->right = NULL; 
  return(node); 
} 
/* Driver program to test above functions*/
int main() 
{ 
  struct node *root = newNode(1); 
  root->left        = newNode(2); 
  root->right       = newNode(3); 
  root->left->left  = newNode(4); 
  root->left->right = newNode(5); 
  root->right->right = newNode(8);     
  root->right->right->left  = newNode(6);     
  root->right->right->right  = newNode(7);       
  
  /* 
   Constructed bunary tree is: 
          1 
        /  \ 
       2    3 
     /  \     \ 
    4   5     8  
              /  \ 
             6   7 
  */  
  printf("Maximum width is %d \n", getMaxWidth(root));   
  getchar(); 
  return 0; 
} 

Java

// Java program to calculate width of binary tree 
   
/* A binary tree node has data, pointer to left child 
   and a pointer to right child */
class Node  
{ 
    int data; 
    Node left, right; 
   
    Node(int item)  
    { 
        data = item; 
        left = right = null; 
    } 
} 
   
class BinaryTree  
{ 
    Node root; 
   
    /* Function to get the maximum width of a binary tree*/
    int getMaxWidth(Node node)  
    { 
        int maxWidth = 0; 
        int width; 
        int h = height(node); 
        int i; 
   
        /* Get width of each level and compare  
           the width with maximum width so far */
        for (i = 1; i <= h; i++)  
        { 
            width = getWidth(node, i); 
            if (width > maxWidth) 
                maxWidth = width; 
        } 
   
        return maxWidth; 
    } 
   
    /* Get width of a given level */
    int getWidth(Node node, int level)  
    { 
        if (node == null) 
            return 0; 
   
        if (level == 1) 
            return 1; 
        else if (level > 1) 
            return getWidth(node.left, level - 1) 
                    + getWidth(node.right, level - 1); 
        return 0; 
    } 
   
    /* UTILITY FUNCTIONS */
      
    /* Compute the "height" of a tree -- the number of 
     nodes along the longest path from the root node 
     down to the farthest leaf node.*/
    int height(Node node)  
    { 
        if (node == null) 
            return 0; 
        else
        { 
            /* compute the height of each subtree */
            int lHeight = height(node.left); 
            int rHeight = height(node.right); 
               
            /* use the larger one */
            return (lHeight > rHeight) ? (lHeight + 1) : (rHeight + 1); 
        } 
    } 
   
    /* Driver program to test above functions */
    public static void main(String args[])  
    { 
        BinaryTree tree = new BinaryTree(); 
          
        /* 
        Constructed bunary tree is: 
              1 
            /  \ 
           2    3 
         /  \    \ 
        4   5     8  
                 /  \ 
                6   7 
         */
        tree.root = new Node(1); 
        tree.root.left = new Node(2); 
        tree.root.right = new Node(3); 
        tree.root.left.left = new Node(4); 
        tree.root.left.right = new Node(5); 
        tree.root.right.right = new Node(8); 
        tree.root.right.right.left = new Node(6); 
        tree.root.right.right.right = new Node(7); 
   
        System.out.println("Maximum width is " + tree.getMaxWidth(tree.root)); 
    } 
} 
   
// This code has been contributed by Mayank Jaiswal 

Python

# Python program to find the maximum width of binary tree using Level Order Traversal. 
  
# A binary tree node 
class Node: 
      
    # Constructor to create a new node 
    def __init__(self, data): 
        self.data = data  
        self.left = None
        self.right = None
  
# Function to get the maximum width of a binary tree 
def getMaxWidth(root): 
    maxWidth = 0
    h = height(root) 
    # Get width of each level and compare the width with maximum width so far 
    for i in range(1,h+1): 
        width = getWidth(root, i) 
        if (width > maxWidth): 
            maxWidth = width 
    return maxWidth 
  
# Get width of a given level 
def getWidth(root,level): 
    if root is None: 
        return 0
    if level == 1: 
        return 1
    elif level > 1: 
        return (getWidth(root.left,level-1) + getWidth(root.right,level-1)) 
  
# UTILITY FUNCTIONS 
# Compute the "height" of a tree -- the number of 
# nodes along the longest path from the root node 
# down to the farthest leaf node. 
def height(node): 
    if node is None: 
        return 0
    else: 
  
        # compute the height of each subtree 
        lHeight = height(node.left) 
        rHeight = height(node.right) 
  
        # use the larger one 
        return (lHeight+1) if (lHeight > rHeight) else (rHeight+1) 
  
# Driver program to test above function 
root = Node(1) 
root.left = Node(2) 
root.right = Node(3) 
root.left.left = Node(4) 
root.left.right = Node(5) 
root.right.right = Node(8) 
root.right.right.left = Node(6) 
root.right.right.right = Node(7)  
  
""" 
Constructed bunary tree is: 
       1 
      / \ 
     2   3 
    / \      \ 
   4   5   8  
          / \ 
         6   7 
"""
  
print "Maximum width is %d" %(getMaxWidth(root)) 
  
# This code is contributed by Naveen Aili 

Time Complexity: O(n^2) in the worst case.

We can use Queue based level order traversal to optimize the time complexity of this method. The Queue based level order traversal will take O(n) time in worst case. Thanks to Nitish, DivyaC and tech.login.id2 for suggesting this optimization. See their comments for implementation using queue based traversal.

Method 2 (Using Level Order Traversal with Queue)
In this method we store all the child nodes at the current level in the queue and then count the total number of nodes after the level order traversal for a particular level is completed. Since the queue now contains all the nodes of the next level, we can easily find out the total number of nodes in the next level by finding the size of queue. We then follow the same procedure for the successive levels. We store and update the maximum number of nodes found at each level.

C++

// A queue based C++ program to find maximum width 
// of 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 data ; 
    struct Node * left ; 
    struct Node * right ; 
}; 
  
// Function to find the maximum width of the tree 
// using level order traversal 
int maxWidth(struct Node * root) 
{ 
    // Base case 
    if (root == NULL) 
        return 0; 
  
    // Initialize result 
    int result = 0; 
  
    // Do Level order traversal keeping track of number 
    // of nodes at every level. 
    queue<Node*> q; 
    q.push(root); 
    while (!q.empty()) 
    { 
        // Get the size of queue when the level order 
        // traversal for one level finishes 
        int count = q.size() ; 
  
        // Update the maximum node count value 
        result = max(count, result); 
  
        // Iterate for all the nodes in the queue currently 
        while (count--) 
        { 
            // Dequeue an node from queue 
            Node *temp = q.front(); 
            q.pop(); 
  
            // Enqueue left and right children of 
            // dequeued node 
            if (temp->left != NULL) 
                q.push(temp->left); 
            if (temp->right != NULL) 
                q.push(temp->right); 
        } 
    } 
  
    return result; 
} 
  
/* Helper function that allocates a new node with the 
   given data and NULL left and right pointers. */
struct Node * newNode(int data) 
{ 
    struct Node * node = new Node; 
    node->data = data; 
    node->left = node->right = NULL; 
    return (node); 
} 
  
int main() 
{ 
    struct Node *root = newNode(1); 
    root->left        = newNode(2); 
    root->right       = newNode(3); 
    root->left->left  = newNode(4); 
    root->left->right = newNode(5); 
    root->right->right = newNode(8); 
    root->right->right->left  = newNode(6); 
    root->right->right->right  = newNode(7); 
  
    /*   Constructed Binary tree is: 
                 1 
               /   \ 
             2      3 
           /  \      \ 
          4    5      8 
                    /   \ 
                   6     7    */
    cout << "Maximum width is "
         << maxWidth(root) << endl; 
    return 0; 
} 
  
// This code is contributed by Nikhil Kumar Singh(nickzuck_007) 

Java

// Java program to calculate maximum width 
// of a binary tree using queue 
import java.util.LinkedList; 
import java.util.Queue; 
  
public class maxwidthusingqueue  
{ 
    /* A binary tree node has data, pointer to  
       left child and a pointer to right child */
    static class node  
    { 
        int data; 
        node left, right; 
  
        public node(int data)  
        { 
            this.data = data; 
        } 
    } 
  
    // Function to find the maximum width of  
    // the tree using level order traversal 
    static int maxwidth(node root)  
    { 
        // Base case 
        if (root == null) 
            return 0; 
          
        // Initialize result 
        int maxwidth = 0; 
          
        // Do Level order traversal keeping  
        // track of number of nodes at every level 
        Queue<node> q = new LinkedList<>(); 
        q.add(root); 
        while (!q.isEmpty())  
        { 
            // Get the size of queue when the level order 
            // traversal for one level finishes 
            int count = q.size(); 
              
            // Update the maximum node count value 
            maxwidth = Math.max(maxwidth, count); 
              
            // Iterate for all the nodes in  
            // the queue currently 
            while (count-- > 0)  
            { 
                // Dequeue an node from queue 
                node temp = q.remove(); 
              
                // Enqueue left and right children  
                // of dequeued node 
                if (temp.left != null)  
                { 
                    q.add(temp.left); 
                } 
                if (temp.right != null)  
                { 
                    q.add(temp.right); 
                } 
            } 
        } 
        return maxwidth; 
    } 
  
    public static void main(String[] args)  
    { 
        node root = new node(1); 
        root.left = new node(2); 
        root.right = new node(3); 
        root.left.left = new node(4); 
        root.left.right = new node(5); 
        root.right.right = new node(8); 
        root.right.right.left = new node(6); 
        root.right.right.right = new node(7); 
  
                /*   Constructed Binary tree is: 
                1 
              /   \ 
            2      3 
          /  \      \ 
         4    5      8 
                   /   \ 
                  6     7    */
                    
        System.out.println("Maximum width = " + maxwidth(root)); 
    } 
} 
  
// This code is contributed by Rishabh Mahrsee 

Python

# Python program to find the maximum width of binary  
# tree using Level Order Traversal with queue. 
  
# A binary tree node 
class Node: 
      
    # Constructor to create a new node 
    def __init__(self, data): 
        self.data = data  
        self.left = None
        self.right = None
  
# Function to get the maximum width of a binary tree 
def getMaxWidth(root): 
    # base case 
    if root is None: 
        return 0
    q = [] 
    maxWidth = 0
      
    q.insert(0,root) 
      
    while (q != []): 
        # Get the size of queue when the level order 
        # traversal for one level finishes 
        count = len(q) 
          
        # Update the maximum node count value 
        maxWidth = max(count,maxWidth) 
          
        while (count is not 0): 
            count = count-1
            temp = q[-1]   
            q.pop() ; 
            if temp.left is not None: 
                q.insert(0,temp.left) 
   
            if temp.right is not None: 
                q.insert(0,temp.right) 
  
    return maxWidth 
  
# Driver program to test above function 
root = Node(1) 
root.left = Node(2) 
root.right = Node(3) 
root.left.left = Node(4) 
root.left.right = Node(5) 
root.right.right = Node(8) 
root.right.right.left = Node(6) 
root.right.right.right = Node(7)  
  
""" 
Constructed bunary tree is: 
       1 
      / \ 
     2   3 
    / \      \ 
   4   5   8  
          / \ 
         6   7 
"""
  
print "Maximum width is %d" %(getMaxWidth(root)) 
  
# This code is contributed by Naveen Aili 

Method 3 (Using Preorder Traversal)
In this method we create a temporary array count[] of size equal to the height of tree. We initialize all values in count as 0. We traverse the tree using preorder traversal and fill the entries in count so that the count array contains count of nodes at each level in Binary Tree.

C

#include <stdio.h> 
#include <stdlib.h> 
  
/* A binary tree node has data, pointer to left child 
   and a pointer to right child */
struct node 
{ 
    int data; 
    struct node* left; 
    struct node* right; 
}; 
  
// A utility function to get height of a binary tree 
int height(struct node* node); 
  
// A utility function to allocate a new node with given data 
struct node* newNode(int data); 
  
// A utility function that returns maximum value in arr[] of size n 
int getMax(int arr[], int n); 
  
// A function that fills count array with count of nodes at every 
// level of given binary tree 
void getMaxWidthRecur(struct node *root, int count[], int level); 
  
  
/* Function to get the maximum width of a binary tree*/
int getMaxWidth(struct node* root) 
{ 
  int width; 
  int h = height(root); 
  
  // Create an array that will store count of nodes at each level 
  int *count = (int *)calloc(sizeof(int), h); 
  
  int level = 0; 
  
  // Fill the count array using preorder traversal 
  getMaxWidthRecur(root, count, level); 
  
  // Return the maximum value from count array 
  return getMax(count, h); 
} 
  
// A function that fills count array with count of nodes at every 
// level of given binary tree 
void getMaxWidthRecur(struct node *root, int count[], int level) 
{ 
  if(root) 
  { 
    count[level]++; 
    getMaxWidthRecur(root->left, count, level+1); 
    getMaxWidthRecur(root->right, count, level+1); 
  } 
} 
  
  
/* UTILITY FUNCTIONS */
/* Compute the "height" of a tree -- the number of 
    nodes along the longest path from the root node 
    down to the farthest leaf node.*/
int height(struct node* node) 
{ 
   if (node==NULL) 
     return 0; 
   else
   { 
     /* compute the height of each subtree */
     int lHeight = height(node->left); 
     int rHeight = height(node->right); 
     /* use the larger one */
  
     return (lHeight > rHeight)? (lHeight+1): (rHeight+1); 
   } 
} 
/* Helper function that allocates a new node with the 
   given data and NULL left and right pointers. */
struct node* newNode(int data) 
{ 
  struct node* node = (struct node*) 
                       malloc(sizeof(struct node)); 
  node->data = data; 
  node->left = NULL; 
  node->right = NULL; 
  return(node); 
} 
  
// Return the maximum value from count array 
int getMax(int arr[], int n) 
{ 
   int max = arr[0]; 
   int i; 
   for (i = 0; i < n; i++) 
   { 
       if (arr[i] > max) 
          max = arr[i]; 
   } 
   return max; 
} 
  
/* Driver program to test above functions*/
int main() 
{ 
  struct node *root = newNode(1); 
  root->left        = newNode(2); 
  root->right       = newNode(3); 
  root->left->left  = newNode(4); 
  root->left->right = newNode(5); 
  root->right->right = newNode(8); 
  root->right->right->left  = newNode(6); 
  root->right->right->right  = newNode(7); 
  
  /* 
   Constructed bunary tree is: 
          1 
        /  \ 
       2    3 
     /  \     \ 
    4   5     8 
              /  \ 
             6   7 
  */
  printf("Maximum width is %d \n", getMaxWidth(root)); 
  getchar(); 
  return 0; 
} 

Java

// Java program to calculate width of binary tree 
   
/* A binary tree node has data, pointer to left child 
   and a pointer to right child */
class Node  
{ 
    int data; 
    Node left, right; 
   
    Node(int item)  
    { 
        data = item; 
        left = right = null; 
    } 
} 
   
class BinaryTree  
{ 
    Node root; 
   
    /* Function to get the maximum width of a binary tree*/
    int getMaxWidth(Node node)  
    { 
        int width; 
        int h = height(node); 
   
        // Create an array that will store count of nodes at each level 
        int count[] = new int[10]; 
   
        int level = 0; 
   
        // Fill the count array using preorder traversal 
        getMaxWidthRecur(node, count, level); 
   
        // Return the maximum value from count array 
        return getMax(count, h); 
    } 
   
    // A function that fills count array with count of nodes at every 
    // level of given binary tree 
    void getMaxWidthRecur(Node node, int count[], int level)  
    { 
        if (node != null)  
        { 
            count[level]++; 
            getMaxWidthRecur(node.left, count, level + 1); 
            getMaxWidthRecur(node.right, count, level + 1); 
        } 
    } 
   
    /* UTILITY FUNCTIONS */
      
    /* Compute the "height" of a tree -- the number of 
     nodes along the longest path from the root node 
     down to the farthest leaf node.*/
    int height(Node node)  
    { 
        if (node == null)  
            return 0; 
        else 
        { 
            /* compute the height of each subtree */
            int lHeight = height(node.left); 
            int rHeight = height(node.right); 
               
            /* use the larger one */
            return (lHeight > rHeight) ? (lHeight + 1) : (rHeight + 1); 
        } 
    } 
       
    // Return the maximum value from count array 
    int getMax(int arr[], int n)  
    { 
        int max = arr[0]; 
        int i; 
        for (i = 0; i < n; i++)  
        { 
            if (arr[i] > max) 
                max = arr[i]; 
        } 
        return max; 
    } 
   
    /* Driver program to test above functions */
    public static void main(String args[])  
    { 
        BinaryTree tree = new BinaryTree(); 
          
        /* 
        Constructed bunary tree is: 
              1 
            /  \ 
           2    3 
          / \    \ 
         4   5    8 
                 / \ 
                6   7 */
        tree.root = new Node(1); 
        tree.root.left = new Node(2); 
        tree.root.right = new Node(3); 
        tree.root.left.left = new Node(4); 
        tree.root.left.right = new Node(5); 
        tree.root.right.right = new Node(8); 
        tree.root.right.right.left = new Node(6); 
        tree.root.right.right.right = new Node(7); 
   
        System.out.println("Maximum width is " +  
                           tree.getMaxWidth(tree.root)); 
    } 
} 
   
// This code has been contributed by Mayank Jaiswal 

Python

# Python program to find the maximum width of binary tree using Preorder Traversal. 
  
# A binary tree node 
class Node: 
      
    # Constructor to create a new node 
    def __init__(self, data): 
        self.data = data  
        self.left = None
        self.right = None
  
# Function to get the maximum width of a binary tree 
def getMaxWidth(root): 
    h = height(root) 
    # Create an array that will store count of nodes at each level 
    count = [0] * h 
      
    level = 0
    # Fill the count array using preorder traversal 
    getMaxWidthRecur(root, count, level) 
      
    # Return the maximum value from count array 
    return getMax(count,h) 
  
# A function that fills count array with count of nodes at every 
# level of given binary tree 
def getMaxWidthRecur(root, count, level): 
    if root is not None: 
        count[level] += 1
        getMaxWidthRecur(root.left, count, level+1) 
        getMaxWidthRecur(root.right, count, level+1) 
  
# UTILITY FUNCTIONS 
# Compute the "height" of a tree -- the number of 
# nodes along the longest path from the root node 
# down to the farthest leaf node. 
def height(node): 
    if node is None: 
        return 0
    else: 
        # compute the height of each subtree 
        lHeight = height(node.left) 
        rHeight = height(node.right) 
        # use the larger one 
        return (lHeight+1) if (lHeight > rHeight) else (rHeight+1) 
  
# Return the maximum value from count array 
def getMax(count, n): 
    max = count[0] 
    for i in range (1,n): 
        if (count[i] > max): 
            max = count[i] 
    return max
          
# Driver program to test above function 
root = Node(1) 
root.left = Node(2) 
root.right = Node(3) 
root.left.left = Node(4) 
root.left.right = Node(5) 
root.right.right = Node(8) 
root.right.right.left = Node(6) 
root.right.right.right = Node(7)  
  
""" 
Constructed bunary tree is: 
       1 
      / \ 
     2   3 
    / \      \ 
   4   5   8  
          / \ 
         6   7 
"""
  
print "Maximum width is %d" %(getMaxWidth(root)) 
  
# This code is contributed by Naveen Aili 