Skip to content
Related Articles

Related Articles

Vertical width of Binary tree | Set 2

View Discussion
Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 12 Aug, 2022
View Discussion
Improve Article
Save Article

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

Examples: 

Input : 
             7
           /  \
          6    5
         / \  / \
        4   3 2  1 
Output : 5

Input :
           1
         /    \
        2       3
       / \     / \
      4   5   6   7
               \   \ 
                8   9 
Output : 6

Prerequisite: Print Binary Tree in Vertical order 

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

Approach: 

In this Approach, we use the approach for printing vertical View of binary tree. Store the horizontal distances in a set and return 1 + highest horizontal distance – lowest horizontal distance. 1 is added to consider horizontal distance 0 as well. While going left, do hd – 1 and for right do hd + 1. We insert all possible distances in a hash table and finally return size of the hash table.

Implementation:

C++




// CPP code to find vertical
// width of a binary tree
#include <bits/stdc++.h>
using namespace std;
 
// Tree class
class Node
{
public :
    int data;
    Node *left, *right;
 
    // Constructor
    Node(int data_new)
    {
        data = data_new;
        left = right = NULL;
    }
};
 
// Function to fill hd in set.
void fillSet(Node* root, unordered_set<int>& s,
                                       int hd)
{
    if (!root)
        return;
 
    fillSet(root->left, s, hd - 1);
    s.insert(hd);
    fillSet(root->right, s, hd + 1);
}
 
int verticalWidth(Node* root)
{
    unordered_set<int> s;
 
    // Third parameter is horizontal
    // distance
    fillSet(root, s, 0);
 
    return s.size();
}
 
int main()
{
    Node* root = NULL;
 
    // Creating the above tree
    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->left = new Node(6);
    root->right->right = new Node(7);
    root->right->left->right = new Node(8);
    root->right->right->right = new Node(9);
 
    cout << verticalWidth(root) << "\n";
 
    return 0;
}

Java




/* Java code to find the vertical width of a binary tree */
import java.io.*;
import java.util.*;
 
/* 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;
 
    /* UTILITY FUNCTIONS */
    // Function to fill hd in set.
    void fillSet(Node root,Set<Integer> set,int hd)
    {
        if(root == null) return;
        fillSet(root.left,set,hd - 1);
        set.add(hd);
        fillSet(root.right,set,hd + 1);
    }
 
 
    int verticalWidth(Node root)
    {
        Set<Integer> set = new HashSet<Integer>();
         
        // Third parameter is horizontal distance
        fillSet(root,set,0);
        return set.size();
    }
     
    /* Driver program to test above functions */
    public static void main(String args[])
    {
        BinaryTree tree = new BinaryTree();
         
        /*
        Constructed binary 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(tree.verticalWidth(tree.root));
         
    }
}
 
/* This code is contributed by Ashok Borra */

Python3




# Python code to find vertical
# width of a binary tree
 
class Node:
    def __init__(self, data):
        self.data = data
        self.left = self.right = None
 
# Function to fill hd in set.
def fillSet(root, s, hd):
    if (not root):
        return
 
    fillSet(root.left, s, hd - 1)
    s.add(hd)
    fillSet(root.right, s, hd + 1)
 
def verticalWidth(root):
    s = set()
 
    # Third parameter is horizontal
    # distance
    fillSet(root, s, 0)
 
    return len(s)
 
if __name__ == '__main__':
 
    # Creating the above tree
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)
    root.right.left = Node(6)
    root.right.right = Node(7)
    root.right.left.right = Node(8)
    root.right.right.right = Node(9)
 
    print(verticalWidth(root))
 
# This code is contributed by PranchalK

C#




// C# code to find the vertical width
// of a binary tree
using System;
using System.Collections.Generic;
 
/* 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;
 
    /* UTILITY FUNCTIONS */
    // Function to fill hd in set.
    void fillSet(Node root, HashSet<int> set, int hd)
    {
        if(root == null) return;
        fillSet(root.left, set, hd - 1);
        set.Add(hd);
        fillSet(root.right, set, hd + 1);
    }
 
    int verticalWidth(Node root)
    {
        HashSet<int> set = new HashSet<int>();
         
        // Third parameter is horizontal distance
        fillSet(root,set, 0);
        return set.Count;
    }
     
    // Driver Code
    public static void Main(String []args)
    {
        BinaryTree tree = new BinaryTree();
         
        /*
        Constructed binary 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(tree.verticalWidth(tree.root));
         
    }
}
 
// This code is contributed by PrinciRaj1992

Javascript




<script>
 
// Javascript code to find the vertical
// width of a binary tree
 
/* A binary tree node has data,
pointer to left child and a
pointer to right child */
class Node
{
    constructor(item)
    {
        this.data = item;
        this.left = null;
        this.right = null;
    }
}
 
var root;
 
/* UTILITY FUNCTIONS */
// Function to fill hd in set.
function fillSet(root,set, hd)
{
    if (root == null)
        return;
         
    fillSet(root.left, set, hd - 1);
    set.add(hd);
    fillSet(root.right, set, hd + 1);
}
 
function verticalWidth(root)
{
    var set = new Set();
     
    // Third parameter is horizontal
    // distance
    fillSet(root,set, 0);
    return set.size;
}
 
// Driver Code
/*
Constructed binary tree is:
     1
    / \
   2   3
  / \   \
 4   5   8
        / \
        6 7
*/
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);
 
document.write(verticalWidth(root));
 
// This code is contributed by rrrtnx
 
</script>

Output

6

My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!