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

 `// C++ program to calculate width of binary tree ` `#include ` `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;  ` `};  ` ` `  `/*Function protoypes*/` `int` `getWidth(node* root, ``int` `level);  ` `int` `height(node* node);  ` `node* newNode(``int` `data);  ` ` `  `/* 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);  ` `    ``}  ` `}  ` ` `  `/* Helper function that allocates a new node with the  ` `given data and NULL left and right pointers. */` `node* newNode(``int` `data)  ` `{  ` `    ``node* Node = ``new` `node(); ` `    ``Node->data = data;  ` `    ``Node->left = NULL;  ` `    ``Node->right = NULL;  ` `    ``return``(Node);  ` `}  ` ` `  `/* Driver code*/` `int` `main()  ` `{  ` `    ``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  ` `    ``*/` `    ``cout<<``"Maximum width is "``<< getMaxWidth(root)<

## C

 `#include ` `#include ` ` `  `/* 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 `

## C#

 `using` `System; ` ` `  `// C# program to calculate width of binary tree  ` ` `  `/* A binary tree node has data, pointer to left child  ` `and a pointer to right child */` `public` `class` `Node ` `{ ` `    ``public` `int` `data; ` `    ``public` `Node left, right; ` ` `  `    ``public` `Node(``int` `item) ` `    ``{ ` `        ``data = item; ` `        ``left = right = ``null``; ` `    ``} ` `} ` ` `  `public` `class` `BinaryTree ` `{ ` `    ``public` `Node root; ` ` `  `    ``/* Function to get the maximum width of a binary tree*/` `    ``public` `virtual` `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 */` `    ``public` `virtual` `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.*/` `    ``public` `virtual` `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); ` ` `  `        ``Console.WriteLine(``"Maximum width is "` `+ tree.getMaxWidth(tree.root)); ` `    ``} ` `} ` ` `  `// This code is contributed by Shrikant13 `

Output:

`Maximum width is 3`

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

## C#

 `// C# program to calculate maximum width  ` `// of a binary tree using queue  ` `using` `System; ` `using` `System.Collections.Generic;  ` ` `  `public` `class` `maxwidthusingqueue  ` `{  ` `    ``/* A binary tree node has data, pointer to  ` `    ``left child and a pointer to right child */` `    ``public` `class` `node  ` `    ``{  ` `        ``public` `int` `data;  ` `        ``public` `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 q = ``new` `Queue();  ` `        ``q.Enqueue(root);  ` `        ``while` `(q.Count!=0)  ` `        ``{  ` `            ``// Get the size of queue when the level order  ` `            ``// traversal for one level finishes  ` `            ``int` `count = q.Count;  ` `             `  `            ``// 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.Dequeue();  ` `             `  `                ``// Enqueue left and right children  ` `                ``// of dequeued node  ` `                ``if` `(temp.left != ``null``)  ` `                ``{  ` `                    ``q.Enqueue(temp.left);  ` `                ``}  ` `                ``if` `(temp.right != ``null``)  ` `                ``{  ` `                    ``q.Enqueue(temp.right);  ` `                ``}  ` `            ``}  ` `        ``}  ` `        ``return` `maxwidth;  ` `    ``}  ` ` `  `    ``// Driver code ` `    ``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 */` `                     `  `        ``Console.WriteLine(``"Maximum width = "` `+ maxwidth(root));  ` `    ``}  ` `}  ` ` `  `// This code is contributed by Princi Singh `

Output:

`Maximum width is 3`

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 ` `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;  ` `};  ` ` `  `// A utility function to get ` `// height of a binary tree  ` `int` `height(node* node);  ` ` `  `// A utility function to allocate ` `// a new node with given data  ` `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(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);  ` `    ``}  ` `}  ` ` `  `/* Helper function that allocates a new node with the  ` `given data and NULL left and right pointers. */` `node* newNode(``int` `data)  ` `{  ` `    ``node* Node = ``new` `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;  ` `    ``int` `i;  ` `    ``for` `(i = 0; i < n; i++)  ` `    ``{  ` `        ``if` `(arr[i] > max)  ` `            ``max = arr[i];  ` `    ``}  ` `    ``return` `max;  ` `}  ` ` `  `/* Driver code*/` `int` `main()  ` `{  ` `    ``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  ` `    ``*/` `    ``cout << ``"Maximum width is "` `<< getMaxWidth(root) << endl;  ` `    ``return` `0;  ` `}  ` ` `  `// This is code is contributed by rathbhupendra `

## C

 `#include ` `#include ` ` `  `/* 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; ` `   ``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 `

## C#

 `// C# program to calculate width of binary tree ` `using` `System; ` ` `  `/* A binary tree node has data,  ` `pointer to left child and  ` `a pointer to right child */` `public` `class` `Node  ` `{ ` `    ``public` `int` `data; ` `    ``public` `Node left, right; ` ` `  `    ``public` `Node(``int` `item)  ` `    ``{ ` `        ``data = item; ` `        ``left = right = ``null``; ` `    ``} ` `} ` ` `  `public` `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``; ` ` `  `        ``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; ` `        ``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); ` ` `  `        ``Console.WriteLine(``"Maximum width is "` `+  ` `                        ``tree.getMaxWidth(tree.root)); ` `    ``} ` `} ` ` `  `// This code is contributed Rajput-Ji  `

Output:

`Maximum width is 3`

Thanks to Raja and jagdish for suggesting this method.

Time Complexity: O(n)

Please write comments if you find the above code/algorithm incorrect, or find better ways to solve the same problem.

My Personal Notes arrow_drop_up