Print Right View of a Binary Tree

Vertical Traversal of a Binary Tree

Last Updated : 04 Feb, 2025

Try it on GfG Practice

Given a Binary Tree, the task is to find its vertical traversal starting from the leftmost level to the rightmost level. If multiple nodes pass through a vertical line, they should be printed as they appear in the level order traversal of the tree.

Examples:

Input:

Output: [[4], [2], [1, 5, 6], [3, 8], [7], [9]]
Explanation: The below image shows the horizontal distances used to print vertical traversal starting from the leftmost level to the rightmost level.

Table of Content

Brute Force Approach – O(n^2) Time and O(n) Space
Using map – O(n*log n) Time and O(n) Space
Using Hashmap – O(n) Time and O(n) Space

[Naive Approach] – O(n^2) Time and O(n) Space

The idea is to traverse the tree once and get the minimum and maximum horizontal distance with respect to root. For the tree shown above, minimum distance is -2 (for node with value 4) and maximum distance is 3 (For node with value 9).
Once we have maximum and minimum distances from root, we iterate for each vertical line at distance minimum to maximum from root, and for each vertical line traverse the tree and return the nodes which lie on that vertical line. Please refer to Vertical Order using Brute Force for this approach.

[Expected Approach – 1] Using DFS and Hashmap – O(n) Time and O(n) Space

The idea is to traverse the tree using dfs and maintain a hashmap to store nodes at each horizontal distance (HD) from the root. Starting with an HD of 0 at the root, the HD is decremented for left children and incremented for right children. As we traverse, we add each node’s value to the map based on its HD. Finally, we collect the nodes from the map in increasing order of HD to produce the vertical order of the tree.

C++

//Driver Code Starts{
// C++ code for Vertical Traversal of a Binary Tree 
// using HashMap and DFS (Depth First Search)

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

class Node {
public:
    int data;
    Node *left, *right;
    
    Node(int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};
//Driver Code Ends }


// Helper function to perform DFS and 
// store nodes at different horizontal distances
void DFS(Node* root, int hd, int &mn, 
         		unordered_map<int, vector<int>> &mp) {
    if (root == nullptr) 
        return;
    
    // Store the current node in the map at horizontal distance hd
    mp[hd].push_back(root->data);
    
    // Update the minimum horizontal distance
    mn = min(mn, hd);
    
    // Recursively traverse the left and right subtrees
    DFS(root->left, hd - 1, mn, mp);  
    DFS(root->right, hd + 1, mn, mp);
}

// Function to perform vertical order traversal of a binary tree
vector<vector<int>> verticalOrder(Node *root) {
  
    // HashMap to store nodes at each horizontal distance
    unordered_map<int, vector<int>> mp;
    
    // Variable to track the minimum horizontal distance
    int mn = 0; 

    // Perform DFS to fill the hashmap with vertical levels
    DFS(root, 0, mn, mp);
    
    vector<vector<int>> res;
    int hd = mn;

    // Traverse the map from minimum to maximum horizontal distance
    while(mp.find(hd) != mp.end()) {
        res.push_back(mp[hd]);
        hd++;
    }
  
    return res;
}


//Driver Code Starts{
int main() {
  
    // Constructing the binary tree:
    //        1
    //       / \
    //      2   3
    //     / \ / \
    //    4  5 6  7
    //          \  \
    //           8  9
    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->left = new Node(6);
    root->right->right = new Node(7);
    root->right->left->right = new Node(8);
    root->right->right->right = new Node(9);
  
    vector<vector<int>> res = verticalOrder(root);
    
    for(vector<int> temp: res) {
        cout << "[ ";
        for (int val: temp) 
            cout << val << " ";
        cout << "] ";
    }
    
    return 0;
}

//Driver Code Ends }

Java

//Driver Code Starts{
// Java code for Vertical Traversal of a Binary Tree 
// using HashMap, DFS, and ArrayList

import java.util.*;

class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
//Driver Code Ends }

  	
  	// Helper function to perform DFS and 
	// store nodes at different horizontal distances
    static void DFS(Node root, int hd, int[] mn, 
                    	HashMap<Integer, ArrayList<Integer>> mp) {
        if (root == null) 
            return;
        
        // Store the current node in the map at horizontal distance hd
        if (!mp.containsKey(hd)) 
            mp.put(hd, new ArrayList<>());
        
        mp.get(hd).add(root.data);
        
        // Update the minimum horizontal distance
        mn[0] = Math.min(mn[0], hd);
        
        // Recursively traverse the left and right subtrees
        DFS(root.left, hd - 1, mn, mp);
        DFS(root.right, hd + 1, mn, mp);
    }

    // Function to perform vertical order traversal of a binary tree
    static ArrayList<ArrayList<Integer>> verticalOrder(Node root) {
      
        // HashMap to store nodes at each horizontal distance
        HashMap<Integer, ArrayList<Integer>> mp = new HashMap<>();
        
        // Array to track the minimum horizontal distance (mutable)
        int[] mn = {0}; 

        // Perform DFS to fill the hashmap with vertical levels
        DFS(root, 0, mn, mp);
        
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        int hd = mn[0];

        // Traverse the map from minimum to maximum horizontal distance
        while (mp.containsKey(hd)) {
            res.add(mp.get(hd));
            hd++;
        }

        return res;
    }


//Driver Code Starts{
    public static void main(String[] args) {
        // Constructing the binary tree:
        //        1
        //       / \
        //      2   3
        //     / \ / \
        //    4  5 6  7
        //          \  \
        //           8  9
        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.left = new Node(6);
        root.right.right = new Node(7);
        root.right.left.right = new Node(8);
        root.right.right.right = new Node(9);

        ArrayList<ArrayList<Integer>> res = verticalOrder(root);
        
        for (ArrayList<Integer> temp : res) {
            System.out.print("[ ");
            for (int val : temp) 
                System.out.print(val + " ");
            System.out.print("] ");
        }
    }
}

//Driver Code Ends }

Python

#Driver Code Starts{
# Python code for Vertical Traversal of a Binary Tree 
# using HashMap and DFS (Depth First Search)

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None
#Driver Code Ends }


# Helper function to perform DFS and 
# store nodes at different horizontal distances
def DFS(root, hd, mn, mp):
    if root is None:
        return
    
    # Store the current node in the map at horizontal distance hd
    if hd not in mp:
        mp[hd] = []
    mp[hd].append(root.data)
    
    # Update the minimum horizontal distance
    mn[0] = min(mn[0], hd)
    
    # Recursively traverse the left and right subtrees
    DFS(root.left, hd - 1, mn, mp)
    DFS(root.right, hd + 1, mn, mp)

# Function to perform vertical order traversal of a binary tree
def verticalOrder(root):
    # Dictionary to store nodes at each horizontal distance
    mp = {}
    
    # List to track the minimum horizontal distance (mutable)
    mn = [0]

    # Perform DFS to fill the dictionary with vertical levels
    DFS(root, 0, mn, mp)
    
    res = []
    hd = mn[0]

    # Traverse the dictionary from minimum to maximum horizontal distance
    while hd in mp:
        res.append(mp[hd])
        hd += 1

    return res


#Driver Code Starts{
if __name__ == "__main__":
    # Constructing the binary tree:
    #        1
    #       / \
    #      2   3
    #     / \ / \
    #    4  5 6  7
    #          \  \
    #           8  9
    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)

    res = verticalOrder(root)
    
    for temp in res:
        print("[", " ".join(map(str, temp)), "]", end=" ")

#Driver Code Ends }

C#

//Driver Code Starts{
// C# code for Vertical Traversal of a Binary Tree 
// using Dictionary and DFS (Depth First Search)

using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
//Driver Code Ends }

  
  	// Helper function to perform DFS and 
	// store nodes at different horizontal distances
    static void DFS(Node root, int hd, ref int mn, Dictionary<int, List<int>> mp) {
        if (root == null)
            return;

        // Store the current node in the dictionary at horizontal distance hd
        if (!mp.ContainsKey(hd))
            mp[hd] = new List<int>();

        mp[hd].Add(root.data);
        
        // Update the minimum horizontal distance
        mn = Math.Min(mn, hd);
        
        // Recursively traverse the left and right subtrees
        DFS(root.left, hd - 1, ref mn, mp);
        DFS(root.right, hd + 1, ref mn, mp);
    }

    // Function to perform vertical order traversal of a binary tree
    static List<List<int>> verticalOrder(Node root) {
      
        // Dictionary to store nodes at each horizontal distance
        Dictionary<int, List<int>> mp = new Dictionary<int, List<int>>();
        
        // Variable to track the minimum horizontal distance
        int mn = 0;

        // Perform DFS to fill the dictionary with vertical levels
        DFS(root, 0, ref mn, mp);
        
        List<List<int>> res = new List<List<int>>();
        int hd = mn;

        // Traverse the dictionary from minimum to maximum horizontal distance
        while (mp.ContainsKey(hd)) {
            res.Add(mp[hd]);
            hd++;
        }

        return res;
    }
  

//Driver Code Starts{
    static void Main() {
        // Constructing the binary tree:
        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.left = new Node(6);
        root.right.right = new Node(7);
        root.right.left.right = new Node(8);
        root.right.right.right = new Node(9);

        List<List<int>> res = verticalOrder(root);
        
        foreach (var temp in res) {
            Console.Write("[ ");
            foreach (var val in temp) 
                Console.Write(val + " ");
            Console.Write("] ");
        }
    }
}
//Driver Code Ends }

JavaScript

//Driver Code Starts{
// JavaScript code for Vertical Traversal of a Binary Tree 
// using HashMap and DFS (Depth First Search)

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}
//Driver Code Ends }


// Helper function to perform DFS and 
// store nodes at different horizontal distances
function DFS(root, hd, mn, mp) {
    if (root === null) 
        return;
    
    // Store the current node in the map at horizontal distance hd
    if (!mp.has(hd)) 
        mp.set(hd, []);
    
    mp.get(hd).push(root.data);
    
    // Update the minimum horizontal distance
    mn.val = Math.min(mn.val, hd);
    
    // Recursively traverse the left and right subtrees
    DFS(root.left, hd - 1, mn, mp);  
    DFS(root.right, hd + 1, mn, mp);
}

// Function to perform vertical order traversal of a binary tree
function verticalOrder(root) {
  
    // Map to store nodes at each horizontal distance
    let mp = new Map();
    
    // Variable to track the minimum horizontal distance
    let mn = { val: 0 }; 

    // Perform DFS to fill the map with vertical levels
    DFS(root, 0, mn, mp);
    
    let res = [];
    let hd = mn.val;

    // Traverse the map from minimum to maximum horizontal distance
    while (mp.has(hd)) {
        res.push(mp.get(hd));
        hd++;
    }
  
    return res;
}


//Driver Code Starts{
// Driver Code
  
// Constructing the binary tree:
//        1
//       / \
//      2   3
//     / \ / \
//    4  5 6  7
//          \  \
//           8  9
let 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);

let res = verticalOrder(root);

let output = "";
res.forEach(temp => {
    output += "[ ";
    temp.forEach(val => output += val + " ");
    output += "] ";
});
console.log(output);

//Driver Code Ends }

Output

[ 4 ] [ 2 ] [ 1 5 6 ] [ 3 8 ] [ 7 ] [ 9 ]

[Expected Approach – 2] Using BFS and Hashmap – O(n) Time and O(n) Space

This approach is similar to the above approach but here we traverse the tree using BFS traversal.
Refer Vertical Traversal of a Binary Tree using BFS for detailed explanation.

Related article:

Find the kth node in vertical order traversal of a Binary Tree

Print Right View of a Binary Tree

kartik

News

Improve

Article Tags :

Practice Tags :

Similar Reads

Queue Data Structure

A Queue Data Structure is a fundamental concept in computer science used for storing and managing data in a specific order. It follows the principle of "First in, First out" (FIFO), where the first element added to the queue is the first one to be removed. Queues are commonly used in various algorit

Introduction to Queue Data Structure

Queue is a linear data structure that follows FIFO (First In First Out) Principle, so the first element inserted is the first to be popped out. FIFO Principle in Queue: FIFO Principle states that the first element added to the Queue will be the first one to be removed or processed. So, Queue is like

Introduction and Array Implementation of Queue

Similar to Stack, Queue is a linear data structure that follows a particular order in which the operations are performed for storing data. The order is First In First Out (FIFO). One can imagine a queue as a line of people waiting to receive something in sequential order which starts from the beginn

Queue - Linked List Implementation

In this article, the Linked List implementation of the queue data structure is discussed and implemented. Print '-1' if the queue is empty. Approach: To solve the problem follow the below idea: we maintain two pointers, front and rear. The front points to the first item of the queue and rear points

Applications, Advantages and Disadvantages of Queue

A Queue is a linear data structure. This data structure follows a particular order in which the operations are performed. The order is First In First Out (FIFO). It means that the element that is inserted first in the queue will come out first and the element that is inserted last will come out last

Different Types of Queues and its Applications

Introduction : A Queue is a linear structure that follows a particular order in which the operations are performed. The order is First In First Out (FIFO). A good example of a queue is any queue of consumers for a resource where the consumer that came first is served first. In this article, the diff