Vertical width of Binary tree | Set 1

Given a binary tree, find the vertical width of the binary tree. The width of a binary tree is the number of vertical paths.

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

Examples :

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 temporary variable if we go left then temp value decreases and if go to right then temp value increases. Assert a condition in this, if the minimum is greater than temp, then minimum = temp and if maximum less then temp then maximum = temp. In the end, print minimum + maximum which is the vertical width of the tree.

C++



filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP program to print vertical width
// of a tree
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to prvertical 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.