Open In App

Maximum width of a Binary Tree

Last Updated : 05 Jun, 2024
Summarize
Comments
Improve
Suggest changes
Like Article
Like
Share
Report
News Follow
Try it on GfG Practice
redirect icon

Given a binary tree, the task is to find the maximum width of the given tree. The width of a tree is the maximum of the widths of all levels. Before solving the problem first, let us understand what we have to do. Binary trees are one of the most common types of trees in computer science. They are also called “balanced” trees because all of their nodes have an equal number of children. In this case, we will focus on finding the maximum value of W, which is the width of a binary tree. For example, given a binary tree with root node A, which has two children B and C, where B has two children D and E and C has one child F, the maximum width is 3.
The maximum width of a binary tree is the number of nodes at any level. In other words, it is the minimum number of nodes in a tree that can be traversed before you need to make a choice on which node to visit next. 

Example: 

Input:
             1
          /   \
       2      3
    /   \       \
 4     5       8 
              /     \
           6        7
Output:  3
Explanation: 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 Practice
Maximum Width of Tree
Try It!

Maximum Width using Level Order Traversal:

To get the width of each level we can use the level order traversal. The maximum among the width of all levels is the required answer.

Level Order Traversal without queue:

This method mainly involves two functions:

  • One is to count nodes at a given level (getWidth), and 
  • The 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 the root.

Given below are the pseudo-codes for the mentioned functions.

getMaxWidth(tree)
maxWdth = 0
for i = 1 to height(tree)
    width =   getWidth(tree, i);
    if(width > maxWdth) 
        maxWdth  = width
return maxWidth

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

Below is the implementation of the above idea:

C++ 
// C++ program to calculate width of 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 */
class node {
public:
    int data;
    node* left;
    node* right;
    node (int d){
      this->data = d;
      this->left = this->right = NULL;
    }
};

/*Function prototypes*/
int getWidth(node* root, int level);
int height(node* node);

/* Function to get the maximum width of a binary tree*/
int getMaxWidth(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(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(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 code*/
int main()
{
    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
    */

    // Function call
    cout << "Maximum width is " << getMaxWidth(root)
         << endl;
    return 0;
}

// This code is contributed by rathbhupendra
C Java Python C# JavaScript

Output
Maximum width is 3

Time Complexity: O(N2) in the worst case.
Auxiliary Space: O(1)

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 the worst case. Thanks to Nitish, DivyaC, and tech.login.id2 for suggesting this optimization. 

Level Order Traversal using Queue

When a queue is used, we can count all the nodes in a level in constant time. This reduces the complexity to be a linear one. 

In this method do the following:

  • Store all the child nodes at the current level in the queue. 
    • 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 the queue. 
  • Follow the same procedure for the successive levels. 
  • Store and update the maximum number of nodes found at each level.

Below is the implementation of the above approach.

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;
    Node(int d)
    {
        this->data = d;
        this->left = this->right = NULL;
    }
};

// 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;
}

// Driver code
int main()
{
    struct 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    */

    // Function call
    cout << "Maximum width is " << maxWidth(root) << endl;
    return 0;
}

// This code is contributed by Nikhil Kumar
// Singh(nickzuck_007)
Java Python C# JavaScript

Output
Maximum width is 3

Time Complexity: O(N) where N is the total number of nodes in the tree. Every node of the tree is processed once and hence the complexity is O(N).
Auxiliary Space: O(w) where w is the maximum width of the tree. 

Maximum width Using Preorder Traversal:

The idea behind this approach is to find the level of a node and increment the count of nodes for that level. The number of nodes present at a certain level is the width of that level.

For traversal we can here use the preorder traversal.

Follow the steps mentioned below to implement the approach:

  • Create a temporary array count[] of size equal to the height of the tree. 
  • Initialize all values in count[] as 0. 
  • Traverse the tree using preorder traversal and fill the entries in count[] so that 
    • The count[] array contains the count of nodes at each level of the Binary Tree.
  • The level with the maximum number of nodes has the maximum width.
  • Return the value of that level. 

Below is the implementation of the above approach.

C++ 
// C++ program to calculate width of 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 */
class node {
public:
    int data;
    node* left;
    node* right;
    node(int d)
    {
        this->data = d;
        this->left = this->right = NULL;
    }
};

// A utility function to get
// height of a binary tree
int height(node* node);

// 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(node* root, int count[], int level);

/* Function to get the maximum
width of a binary tree*/
int getMaxWidth(node* root)
{
    int width;
    int h = height(root);

    // Create an array that will
    // store count of nodes at each level
    int* count = new 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(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(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 code*/
int main()
{
    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);

    cout << "Maximum width is " << getMaxWidth(root)
         << endl;
    return 0;
}

// This is code is contributed by rathbhupendra
C Java Python C# JavaScript

Output
Maximum width is 3

Time Complexity: O(N)
Auxiliary Space: O(h) where h is the height of the tree.

Thanks to Raja and Jagdish for suggesting this method.
Please write comments if you find the above code/algorithm incorrect, or find better ways to solve the same problem.

Maximum width Using a Special form of level Order Traversal:

We will perform a special level order traversal with two loops where inner loops traverses the nodes of a single level. This is to ensure that we can do our calculations once a single level is traversed. In the traversal, we will assign an index to a node.

Below is the implementation of the above Approach:

C++ 
#include <bits/stdc++.h>

using namespace std;

struct node {
  int data;
  struct node * left, * right;
};

int widthOfBinaryTree(node * root) {
  if (!root)
    return 0;
  int ans = 0;
  queue < pair < node * , int >> q;
  q.push({
    root,
    0
  });
  while (!q.empty()) {
    int size = q.size();
    int curMin = q.front().second;
    int leftMost, rightMost;
    for (int i = 0; i < size; i++) {
      int cur_id = q.front().second - curMin; // subtracted to prevent integer overflow
      node * temp = q.front().first;
      q.pop();
      if (i == 0) leftMost = cur_id;
      if (i == size - 1) rightMost = cur_id;
      if (temp -> left)
        q.push({
          temp -> left,
          cur_id * 2 + 1
        });
      if (temp -> right)
        q.push({
          temp -> right,
          cur_id * 2 + 2
        });
    }
    ans = max(ans, rightMost - leftMost + 1);
  }
  return ans;
}

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);
}

int main() {

  struct node * root = newNode(1);
  root -> left = newNode(3);
  root -> left -> left = newNode(5);
  root -> left -> left -> left = newNode(7);
  root -> right = newNode(2);
  root -> right -> right = newNode(4);
  root -> right -> right -> right = newNode(6);

  int maxWidth = widthOfBinaryTree(root);
  cout << "The maximum width of the Binary Tree is " << maxWidth;
  
  return 0;
}
//This code is given by Kushagra Mishra.
Java Python C# JavaScript

Output
The maximum width of the Binary Tree is 8

Time Complexity : O(N)
Space Complexity : O(N)



Next Article
Maximum width of an N-ary tree
author
kartik
News
Improve
Article Tags :
Practice Tags :

Similar Reads

three90RightbarBannerImg
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox