# Vertical width of Binary tree | Set 1

• Difficulty Level : Easy
• Last Updated : 23 Sep, 2022

Given a Binary tree, the task is to find the vertical width of the Binary tree. The width of a binary tree is the number of vertical paths in the Binary tree.

Examples:

Input: Output: 6
Explanation: In this image, the tree contains 6 vertical lines which are the required width of the tree.

Input :

7

/  \

6    5

/ \  / \

4   3 2  1

Output : 5

Input:

1

/    \

2       3

/ \     / \

4   5   6   7

\   \

8   9

Output :  6

Approach:

Take inorder traversal and then take a temp variable to keep the track of unique vertical paths. when moving to left of the node then temp decreases by one and if goes to right then temp value increases by one. If the minimum is greater than temp, then update minimum = temp and if maximum less than temp then update maximum = temp. The vertical width of the tree will be equal to abs(minimum ) + maximum.

Follow the below steps to Implement the idea:

• Initialize a minimum and maximum variable to track the left-most and right-most index.
• Run Depth-first search traversal and maintain the current horizontal index curr, for root curr = 0.
• Traverse left subtree with curr = curr-1
• Update maximum with curr if curr > maximum.
• Update minimum with curr if curr < minimum.
• Traverse right subtree with curr = curr + 1.
• Print the vertical width of the tree i.e. abs(minimum ) + maximum.

Below is the Implementation of the above approach:

## C++

 `// CPP program to print vertical width``// of a tree``#include ``using` `namespace` `std;` `// A Binary Tree Node``struct` `Node {``    ``int` `data;``    ``struct` `Node *left, *right;``};` `// get vertical width``void` `lengthUtil(Node* root, ``int``& maximum, ``int``& minimum,``                ``int` `curr = 0)``{``    ``if` `(root == NULL)``        ``return``;` `    ``// traverse left``    ``lengthUtil(root->left, maximum, minimum, curr - 1);` `    ``// if curr is decrease then get``    ``// value in minimum``    ``if` `(minimum > curr)``        ``minimum = curr;` `    ``// if curr is increase then get``    ``// value in maximum``    ``if` `(maximum < curr)``        ``maximum = curr;` `    ``// traverse right``    ``lengthUtil(root->right, maximum, minimum, curr + 1);``}` `int` `getLength(Node* root)``{``    ``int` `maximum = 0, minimum = 0;``    ``lengthUtil(root, maximum, minimum, 0);` `    ``// 1 is added to include root in the width``    ``return` `(``abs``(minimum) + maximum) + 1;``}` `// Utility function to create a new tree node``Node* newNode(``int` `data)``{``    ``Node* curr = ``new` `Node;``    ``curr->data = data;``    ``curr->left = curr->right = NULL;``    ``return` `curr;``}` `// Driver program to test above functions``int` `main()``{` `    ``Node* root = newNode(7);``    ``root->left = newNode(6);``    ``root->right = newNode(5);``    ``root->left->left = newNode(4);``    ``root->left->right = newNode(3);``    ``root->right->left = newNode(2);``    ``root->right->right = newNode(1);` `    ``cout << getLength(root) << ``"\n"``;` `    ``return` `0;``}`

## Java

 `// Java program to print vertical width``// of a tree``import` `java.util.*;` `class` `GFG {` `    ``// A Binary Tree Node``    ``static` `class` `Node {``        ``int` `data;``        ``Node left, right;``    ``};``    ``static` `int` `maximum = ``0``, minimum = ``0``;` `    ``// get vertical width``    ``static` `void` `lengthUtil(Node root, ``int` `curr)``    ``{``        ``if` `(root == ``null``)``            ``return``;` `        ``// traverse left``        ``lengthUtil(root.left, curr - ``1``);` `        ``// if curr is decrease then get``        ``// value in minimum``        ``if` `(minimum > curr)``            ``minimum = curr;` `        ``// if curr is increase then get``        ``// value in maximum``        ``if` `(maximum < curr)``            ``maximum = curr;` `        ``// traverse right``        ``lengthUtil(root.right, curr + ``1``);``    ``}` `    ``static` `int` `getLength(Node root)``    ``{``        ``maximum = ``0``;``        ``minimum = ``0``;``        ``lengthUtil(root, ``0``);` `        ``// 1 is added to include root in the width``        ``return` `(Math.abs(minimum) + maximum) + ``1``;``    ``}` `    ``// Utility function to create a new tree node``    ``static` `Node newNode(``int` `data)``    ``{``        ``Node curr = ``new` `Node();``        ``curr.data = data;``        ``curr.left = curr.right = ``null``;``        ``return` `curr;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``Node root = newNode(``7``);``        ``root.left = newNode(``6``);``        ``root.right = newNode(``5``);``        ``root.left.left = newNode(``4``);``        ``root.left.right = newNode(``3``);``        ``root.right.left = newNode(``2``);``        ``root.right.right = newNode(``1``);` `        ``System.out.println(getLength(root));``    ``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program to print vertical width``# of a tree` `# class to create a new tree node`  `class` `newNode:``    ``def` `__init__(``self``, data):``        ``self``.data ``=` `data``        ``self``.left ``=` `self``.right ``=` `None` `# get vertical width`  `def` `lengthUtil(root, maximum, minimum, curr``=``0``):``    ``if` `(root ``=``=` `None``):``        ``return` `    ``# traverse left``    ``lengthUtil(root.left, maximum,``               ``minimum, curr ``-` `1``)` `    ``# if curr is decrease then get``    ``# value in minimum``    ``if` `(minimum[``0``] > curr):``        ``minimum[``0``] ``=` `curr` `    ``# if curr is increase then get``    ``# value in maximum``    ``if` `(maximum[``0``] < curr):``        ``maximum[``0``] ``=` `curr` `    ``# traverse right``    ``lengthUtil(root.right, maximum,``               ``minimum, curr ``+` `1``)`  `def` `getLength(root):``    ``maximum ``=` `[``0``]``    ``minimum ``=` `[``0``]``    ``lengthUtil(root, maximum, minimum, ``0``)` `    ``# 1 is added to include root in the width``    ``return` `(``abs``(minimum[``0``]) ``+` `maximum[``0``]) ``+` `1`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``root ``=` `newNode(``7``)``    ``root.left ``=` `newNode(``6``)``    ``root.right ``=` `newNode(``5``)``    ``root.left.left ``=` `newNode(``4``)``    ``root.left.right ``=` `newNode(``3``)``    ``root.right.left ``=` `newNode(``2``)``    ``root.right.right ``=` `newNode(``1``)` `    ``print``(getLength(root))` `# This code is contributed by PranchalK`

## C#

 `// C# program to print vertical width``// of a tree``using` `System;` `class` `GFG {` `    ``// A Binary Tree Node``    ``public` `class` `Node {``        ``public` `int` `data;``        ``public` `Node left, right;``    ``};``    ``static` `int` `maximum = 0, minimum = 0;` `    ``// get vertical width``    ``static` `void` `lengthUtil(Node root, ``int` `curr)``    ``{``        ``if` `(root == ``null``)``            ``return``;` `        ``// traverse left``        ``lengthUtil(root.left, curr - 1);` `        ``// if curr is decrease then get``        ``// value in minimum``        ``if` `(minimum > curr)``            ``minimum = curr;` `        ``// if curr is increase then get``        ``// value in maximum``        ``if` `(maximum < curr)``            ``maximum = curr;` `        ``// traverse right``        ``lengthUtil(root.right, curr + 1);``    ``}` `    ``static` `int` `getLength(Node root)``    ``{``        ``maximum = 0;``        ``minimum = 0;``        ``lengthUtil(root, 0);` `        ``// 1 is added to include root in the width``        ``return` `(Math.Abs(minimum) + maximum) + 1;``    ``}` `    ``// Utility function to create a new tree node``    ``static` `Node newNode(``int` `data)``    ``{``        ``Node curr = ``new` `Node();``        ``curr.data = data;``        ``curr.left = curr.right = ``null``;``        ``return` `curr;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``Node root = newNode(7);``        ``root.left = newNode(6);``        ``root.right = newNode(5);``        ``root.left.left = newNode(4);``        ``root.left.right = newNode(3);``        ``root.right.left = newNode(2);``        ``root.right.right = newNode(1);` `        ``Console.WriteLine(getLength(root));``    ``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output

`5`

Time Complexity: O(n)
Auxiliary Space: O(h) where h is the height of the binary tree. This much space is needed for recursive calls.

## Find vertical width of Binary tree using Level Order Traversal:

Below is the idea to solve the problem:

Create a class to store the node and the horizontal level of the node. The horizontal level of left node will be 1 less than its parent, and horizontal level of the right node will be 1 more than its parent. We create a minLevel variable to store the minimum horizontal level or the leftmost node in the tree, and a maxLevel variable to store the maximum horizontal level or the rightmost node in the tree. Traverse the tree in level order and store the minLevel and maxLevel. In the end, print sum of maxLevel and absolute value of minLevel which is the vertical width of the tree.

Follow the below steps to Implement the idea:

• Initialize two variables maxLevel = 0 and minLevel = 0 and queue Q of pair of the type (Node*, Integer).
• Push (root, 0) in Q.
• Run while loop till Q is not empty
• Store the front node of the Queue in cur and the current horizontal level in count.
• If curr->left is not null then push (root->left, count-1) and update minLevel with min(minLevel, count-1).
• If curr->right is not null then push (root->right, count+1) and update maxLevel with max(maxLevel, count+1).
• Print maxLevel + abs(minLevel) + 1.

Below is the Implementation of the above approach:

## C++

 `// C++ program to find Vetical Height of a tree` `#include ``#include ` `using` `namespace` `std;` `struct` `Node {``    ``int` `data;``    ``struct` `Node* left;``    ``struct` `Node* right;` `    ``Node(``int` `x)``    ``{``        ``data = x;``        ``left = right = NULL;``    ``}``};` `int` `verticalWidth(Node* root)``{``    ``// Code here``    ``if` `(root == NULL)``        ``return` `0;` `    ``int` `maxLevel = 0, minLevel = 0;``    ``queue > q;``    ``q.push({ root, 0 }); ``// we take root as 0` `    ``// Level order traversal code``    ``while` `(q.empty() != ``true``) {``        ``Node* cur = q.front().first;``        ``int` `count = q.front().second;``        ``q.pop();` `        ``if` `(cur->left) {``            ``minLevel = min(minLevel,``                           ``count - 1); ``// as we go left,``                                       ``// level is decreased``            ``q.push({ cur->left, count - 1 });``        ``}` `        ``if` `(cur->right) {``            ``maxLevel = max(maxLevel,``                           ``count + 1); ``// as we go right,``                                       ``// level is increased``            ``q.push({ cur->right, count + 1 });``        ``}``    ``}` `    ``return` `maxLevel + ``abs``(minLevel)``           ``+ 1; ``// +1 for the root node, we gave it a value``                ``// of zero``}` `int` `main()``{``    ``// making the tree``    ``Node* root = ``new` `Node(7);``    ``root->left = ``new` `Node(6);``    ``root->right = ``new` `Node(5);``    ``root->left->left = ``new` `Node(4);``    ``root->left->right = ``new` `Node(3);``    ``root->right->left = ``new` `Node(2);``    ``root->right->right = ``new` `Node(1);` `    ``cout << ``"Vertical width is : "` `<< verticalWidth(root)``         ``<< endl;``    ``return` `0;``}` `// code contributed by Anshit Bansal`

## Java

 `// Java program to print vertical width``// of a tree``import` `java.util.*;` `class` `GFG {` `    ``// A Binary Tree Node``    ``static` `class` `Node {``        ``int` `data;``        ``Node left, right;``    ``};``    ``static` `class` `Pair {``        ``Node node;``        ``int` `level; ``// Horizontal Level``        ``Pair(Node node, ``int` `level)``        ``{``            ``this``.node = node;``            ``this``.level = level;``        ``}``    ``}``    ``static` `int` `maxLevel = ``0``, minLevel = ``0``;` `    ``// get vertical width``    ``static` `void` `lengthUtil(Node root)``    ``{``        ``Queue q = ``new` `ArrayDeque<>();` `        ``// Adding the root node initially with level as 0;``        ``q.add(``new` `Pair(root, ``0``));` `        ``while` `(q.size() > ``0``) {``            ``// removing the node at the peek of queue;``            ``Pair rem = q.remove();` `            ``// If the left child of removed node exists``            ``if` `(rem.node.left != ``null``) {``                ``// level of the left child will be 1 less``                ``// than its parent``                ``q.add(``                    ``new` `Pair(rem.node.left, rem.level - ``1``));``                ``// updating the minLevel``                ``minLevel``                    ``= Math.min(minLevel, rem.level - ``1``);``            ``}` `            ``// If the right child of removed node exists``            ``if` `(rem.node.right != ``null``) {``                ``// level of the right child will be 1 more``                ``// than its parent``                ``q.add(``new` `Pair(rem.node.right,``                               ``rem.level + ``1``));``                ``// updating the minLevel``                ``maxLevel``                    ``= Math.max(minLevel, rem.level + ``1``);``            ``}``        ``}``    ``}` `    ``static` `int` `getLength(Node root)``    ``{``        ``maxLevel = ``0``;``        ``minLevel = ``0``;``        ``lengthUtil(root);` `        ``// 1 is added to include root in the width``        ``return` `(Math.abs(minLevel) + maxLevel) + ``1``;``    ``}` `    ``// Utility function to create a new tree node``    ``static` `Node newNode(``int` `data)``    ``{``        ``Node curr = ``new` `Node();``        ``curr.data = data;``        ``curr.left = curr.right = ``null``;``        ``return` `curr;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``Node root = newNode(``7``);``        ``root.left = newNode(``6``);``        ``root.right = newNode(``5``);``        ``root.left.left = newNode(``4``);``        ``root.left.right = newNode(``3``);``        ``root.right.left = newNode(``2``);``        ``root.right.right = newNode(``1``);` `        ``System.out.println(getLength(root));``    ``}``}` `// This code is contributed by Archit Sharma`

## C#

 `// C# program to print vertical width of a tree``using` `System;``using` `System.Collections;` `public` `class` `GFG {` `    ``// A Binary Tree Node``    ``class` `Node {``        ``public` `int` `data;``        ``public` `Node left, right;``    ``};` `    ``class` `Pair {``        ``public` `Node node;``        ``public` `int` `level; ``// Horizontal Level``        ``public` `Pair(Node node, ``int` `level)``        ``{``            ``this``.node = node;``            ``this``.level = level;``        ``}``    ``}` `    ``static` `int` `maxLevel = 0, minLevel = 0;` `    ``// get vertical width``    ``static` `void` `lengthUtil(Node root)``    ``{``        ``Queue q = ``new` `Queue();` `        ``// Adding the root node initially with level as 0;``        ``q.Enqueue(``new` `Pair(root, 0));` `        ``while` `(q.Count > 0) {``            ``// removing the node at the peek of queue;``            ``Pair rem = (Pair)q.Dequeue();` `            ``// If the left child of removed node exists``            ``if` `(rem.node.left != ``null``) {``                ``// level of the left child will be 1 less``                ``// than its parent``                ``q.Enqueue(``                    ``new` `Pair(rem.node.left, rem.level - 1));``                ``// updating the minLevel``                ``minLevel``                    ``= Math.Min(minLevel, rem.level - 1);``            ``}` `            ``// If the right child of removed node exists``            ``if` `(rem.node.right != ``null``) {``                ``// level of the right child will be 1 more``                ``// than its parent``                ``q.Enqueue(``new` `Pair(rem.node.right,``                                   ``rem.level + 1));``                ``// updating the minLevel``                ``maxLevel``                    ``= Math.Max(minLevel, rem.level + 1);``            ``}``        ``}``    ``}` `    ``static` `int` `getLength(Node root)``    ``{``        ``maxLevel = 0;``        ``minLevel = 0;``        ``lengthUtil(root);` `        ``// 1 is added to include root in the width``        ``return` `(Math.Abs(minLevel) + maxLevel) + 1;``    ``}` `    ``// Utility function to create a new tree node``    ``static` `Node newNode(``int` `data)``    ``{``        ``Node curr = ``new` `Node();``        ``curr.data = data;``        ``curr.left = curr.right = ``null``;``        ``return` `curr;``    ``}` `    ``static` `public` `void` `Main()``    ``{` `        ``// Code``        ``Node root = newNode(7);``        ``root.left = newNode(6);``        ``root.right = newNode(5);``        ``root.left.left = newNode(4);``        ``root.left.right = newNode(3);``        ``root.right.left = newNode(2);``        ``root.right.right = newNode(1);` `        ``Console.WriteLine(getLength(root));``    ``}``}` `// This code is contributed by lokeshmvs21.`

Output

`5`

Time Complexity: O(n). This much time is needed to traverse the tree.
Auxiliary Space: O(n). This much space is needed to maintain the queue.

My Personal Notes arrow_drop_up