Print nodes in top view of Binary Tree | Set 2

Top view of a binary tree is the set of nodes visible when the tree is viewed from the top. Given a binary tree, print the top view of it. The output nodes should be printed from left to right. 

Note: A node x is there in output if x is the topmost node at its horizontal distance. Horizontal distance of the left child of a node x is equal to the horizontal distance of x minus 1, and that of right child is the horizontal distance of x plus 1. 

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

Input:
        1
      /   \
    2       3
      \   
        4  
          \
            5
             \
               6
Output: Top view: 2 1 3 6

The idea is to do something similar to Vertical Order Traversal. Like Vertical Order Traversal, we need to group nodes of same horizontal distance together. We do a level order traversal so that the topmost node at a horizontal node is visited before any other node of same horizontal distance below it. A Map is used to map the horizontal distance of the node with the node’s Data and vertical distance of the node.

Below is the implementation of the above approach:

C++

// C++ Program to print Top View of Binary Tree
// using hashmap and recursion
#include <bits/stdc++.h>
using namespace std;

// Node structure
struct Node {
    // Data of the node
    int data;

    // Horizontal Distance of the node
    int hd;

    // Reference to left node
    struct Node* left;

    // Reference to right node
    struct Node* right;
};

// Initialising node
struct Node* newNode(int data)
{
    struct Node* node = new Node;
    node->data = data;
    node->hd = INT_MAX;
    node->left = NULL;
    node->right = NULL;
    return node;
}

void printTopViewUtil(Node* root, int height,
    int hd, map<int, pair<int, int> >& m)
{
    // Base Case
    if (root == NULL)
        return;

    // If the node for particular horizontal distance
    // is not present in the map, add it.
    // For top view, we consider the first element
    // at horizontal distance in level order traversal
    if (m.find(hd) == m.end()) {
        m[hd] = make_pair(root->data, height);
    }
    else{
        pair<int, int> p = (m.find(hd))->second;

        if (p.second > height) {
            m.erase(hd);
            m[hd] = make_pair(root->data, height);
        }
    }

    // Recur for left and right subtree
    printTopViewUtil(root->left, height + 1, hd - 1, m);
    printTopViewUtil(root->right, height + 1, hd + 1, m);
}

void printTopView(Node* root)
{
    // Map to store horizontal distance,
    // height and node's data
    map<int, pair<int, int> > m;
    printTopViewUtil(root, 0, 0, m);

    // Print the node's value stored by printTopViewUtil()
    for (map<int, pair<int, int> >::iterator it = m.begin();
                                        it != m.end(); it++) {
        pair<int, int> p = it->second;
        cout << p.first << " ";
    }
}

int main()
{
    Node* root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->right = newNode(4);
    root->left->right->right = newNode(5);
    root->left->right->right->right = newNode(6);

    cout << "Top View : ";
    printTopView(root);

    return 0;
}

Java

// Java Program to print Top View of Binary Tree
// using hashmap and recursion
import java.util.*;

class GFG {

    // Node structure
    static class Node {
        // Data of the node
        int data;

        // Reference to left node
        Node left;

        // Reference to right node
        Node right;
    };
    static class pair {
        int data, height;
        public pair(int data, int height)
        {
            this.data = data;
            this.height = height;
        }
    }

    // Initialising node
    static Node newNode(int data)
    {
        Node node = new Node();
        node.data = data;
        node.left = null;
        node.right = null;
        return node;
    }

    static void printTopViewUtil(Node root, int height,
                                 int hd,
                                 Map<Integer, pair> m)
    {
        // Base Case
        if (root == null)
            return;

        // If the node for particular horizontal distance
        // is not present in the map, add it.
        // For top view, we consider the first element
        // at horizontal distance in level order traversal
        if (!m.containsKey(hd)) {
            m.put(hd, new pair(root.data, height));
        }
        else {
            pair p = m.get(hd);

            if (p.height >= height) {
                m.put(hd, new pair(root.data, height));
            }
        }

        // Recur for left and right subtree
        printTopViewUtil(root.left, height + 1, hd - 1, m);
        printTopViewUtil(root.right, height + 1, hd + 1, m);
    }

    static void printTopView(Node root)
    {
        // Map to store horizontal distance,
        // height and node's data
        Map<Integer, pair> m = new TreeMap<>();
        printTopViewUtil(root, 0, 0, m);

        // Print the node's value stored by
        // printTopViewUtil()
        for (Map.Entry<Integer, pair> it : m.entrySet()) {
            pair p = it.getValue();
            System.out.print(p.data + " ");
        }
    }

    // Driver code
    public static void main(String[] args)
    {
        Node root = newNode(1);
        root.left = newNode(2);
        root.right = newNode(3);
        root.left.right = newNode(4);
        root.left.right.right = newNode(5);
        root.left.right.right.right = newNode(6);

        System.out.print("Top View : ");
        printTopView(root);
    }
}

Python3

# Python3 Program to prTop View of
# Binary Tree using hash and recursion
from collections import OrderedDict

# A binary tree node
class newNode:

    # A constructor to create a
    # new Binary tree Node
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
        self.hd = 2**32

def printTopViewUtil(root, height, hd, m):

    # Base Case
    if (root == None):
        return

    # If the node for particular horizontal
    # distance is not present in the map, add it.
    # For top view, we consider the first element
    # at horizontal distance in level order traversal
    if hd not in m :
        m[hd] = [root.data, height]
    else:
        p = m[hd]
        if p[1] > height:
            m[hd] = [root.data, height]

    # Recur for left and right subtree
    printTopViewUtil(root.left,
                     height + 1, hd - 1, m)
    printTopViewUtil(root.right,
                     height + 1, hd + 1, m)

def printTopView(root):

    # to store horizontal distance,
    # height and node's data
    m = OrderedDict()
    printTopViewUtil(root, 0, 0, m)

    # Print the node's value stored
    # by printTopViewUtil()
    for i in sorted(list(m)):
        p = m[i]
        print(p[0], end = " ")

# Driver Code
root = newNode(1)
root.left = newNode(2)
root.right = newNode(3)
root.left.right = newNode(4)
root.left.right.right = newNode(5)
root.left.right.right.right = newNode(6)

print("Top View : ", end = "")
printTopView(root)

# This code is contributed by SHUBHAMSINGH10

C#

// C# program to print Top View of Binary
// Tree using hashmap and recursion
using System;
using System.Collections.Generic;

class GFG{

// Node structure
class Node
{

    // Data of the node
    public int data;

    // Reference to left node
    public Node left;

    // Reference to right node
    public Node right;
};

class pair
{
    public int data, height;

    public pair(int data, int height)
    {
        this.data = data;
        this.height = height;
    }
}

// Initialising node
static Node newNode(int data)
{
    Node node = new Node();
    node.data = data;
    node.left = null;
    node.right = null;
    return node;
}

static void printTopViewUtil(Node root, int height,
                             int hd,
                             SortedDictionary<int, pair> m)
{

    // Base Case
    if (root == null)
        return;

    // If the node for particular horizontal distance
    // is not present in the map, add it.
    // For top view, we consider the first element
    // at horizontal distance in level order traversal
    if (!m.ContainsKey(hd))
    {
        m[hd] = new pair(root.data, height);
    }
    else
    {
        pair p = m[hd];

        if (p.height >= height)
        {
            m[hd] = new pair(root.data, height);
        }
    }

    // Recur for left and right subtree
    printTopViewUtil(root.left, height + 1,
                     hd - 1, m);
    printTopViewUtil(root.right, height + 1,
                     hd + 1, m);
}

static void printTopView(Node root)
{

    // Map to store horizontal distance,
    // height and node's data
    SortedDictionary<int,
                     pair> m = new SortedDictionary<int,
                                                    pair>();

    printTopViewUtil(root, 0, 0, m);

    // Print the node's value stored by
    // printTopViewUtil()
    foreach(var it in m.Values)
    {
        Console.Write(it.data + " ");
    }
}

// Driver code
public static void Main(string[] args)
{
    Node root = newNode(1);
    root.left = newNode(2);
    root.right = newNode(3);
    root.left.right = newNode(4);
    root.left.right.right = newNode(5);
    root.left.right.right.right = newNode(6);

    Console.Write("Top View : ");

    printTopView(root);
}
}

// This code is contributed by rutvik_56

Javascript

<script>

// JavaScript program to print Top View of Binary
// Tree using hashmap and recursion

// Node structure
class Node
{
    constructor()
    {
      // Data of the node
      this.data = 0;
      // Reference to left node
      this.left = null;
      // Reference to right node
      this.right = null;
    }
};

class pair
{
  constructor(data, height)
  {
    this.data = data;
    this.height = height;
  }
}

// Initialising node
function newNode(data)
{
    var node = new Node();
    node.data = data;
    node.left = null;
    node.right = null;
    return node;
}

function printTopViewUtil(root, height, hd, m)
{

    // Base Case
    if (root == null)
        return;

    // If the node for particular horizontal distance
    // is not present in the map, add it.
    // For top view, we consider the first element
    // at horizontal distance in level order traversal
    if (!m.has(hd))
    {
        m.set(hd, new pair(root.data, height));
    }
    else
    {
        var p = m.get(hd);

        if (p.height >= height)
        {
            m.set(hd, new pair(root.data, height));
        }
    }

    // Recur for left and right subtree
    printTopViewUtil(root.left, height + 1,
                     hd - 1, m);
    printTopViewUtil(root.right, height + 1,
                     hd + 1, m);
}

function printTopView(root)
{

    // Map to store horizontal distance,
    // height and node's data
    var m = new Map();

    printTopViewUtil(root, 0, 0, m);

    // Print the node's value stored by
    // printTopViewUtil()
    for(var it of [...m].sort())
    {
        document.write(it[1].data + " ");
    }
}

// Driver code
var root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.right = newNode(4);
root.left.right.right = newNode(5);
root.left.right.right.right = newNode(6);
document.write("Top View : ");
printTopView(root);


</script>

Output

Top View : 2 1 3 6

Complexity Analysis:

• Time complexity: O(n) where n is number of nodes of binary tree
• Auxiliary space: O(n) for call stack

Approach#2: Using deque

We use a level order traversal technique to traverse the tree and maintain a dictionary to store the horizontal distance of each node from the root node. We keep adding nodes to the queue along with their horizontal distance from the root node. Then, we traverse the dictionary and print the values of the nodes with the minimum horizontal distance from the root node.

Algorithm

1. Create an empty dictionary to store the horizontal distance of each node from the root node.
2. Create a queue and enqueue the root node along with its horizontal distance, which is zero.
3. Traverse the tree using a level order traversal technique:
a. Dequeue a node and its horizontal distance from the queue.
b. If the horizontal distance is not present in the dictionary, add the node’s value to the dictionary with its horizontal distance.
c. Enqueue the left child of the dequeued node with its horizontal distance decreased by 1.
d. Enqueue the right child of the dequeued node with its horizontal distance increased by 1.
4. Traverse the dictionary and print the values of the nodes with the minimum horizontal distance from the root node.

Python3

from collections import deque

class Node:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def top_view(root):
    hd_dict = {}
    q = deque([(root, 0)])
    while q:
        node, hd = q.popleft()
        if hd not in hd_dict:
            hd_dict[hd] = node.val
        if node.left:
            q.append((node.left, hd-1))
        if node.right:
            q.append((node.right, hd+1))
    for hd in sorted(hd_dict.keys()):
        print(hd_dict[hd], end=' ')

# Example usage
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)

print("Top view: ", end='')
top_view(root)

Java

import java.util.*;

class Node {
    int val;
    Node left;
    Node right;

    public Node(int val) {
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

public class Main {
    public static void topView(Node root) {
        if (root == null) {
            return;
        }

        Map<Integer, Integer> hdMap = new TreeMap<>();
        Queue<Node> queue = new LinkedList<>();
        Queue<Integer> hdQueue = new LinkedList<>();

        queue.offer(root);
        hdQueue.offer(0);

        while (!queue.isEmpty()) {
            Node currNode = queue.poll();
            int currHd = hdQueue.poll();

            if (!hdMap.containsKey(currHd)) {
                hdMap.put(currHd, currNode.val);
            }

            if (currNode.left != null) {
                queue.offer(currNode.left);
                hdQueue.offer(currHd - 1);
            }

            if (currNode.right != null) {
                queue.offer(currNode.right);
                hdQueue.offer(currHd + 1);
            }
        }

        for (int hd : hdMap.keySet()) {
            System.out.print(hdMap.get(hd) + " ");
        }
    }

    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.left = new Node(6);
        root.right.right = new Node(7);

        System.out.print("Top view: ");
        topView(root);
    }
}

Output

Top view: 4 2 1 3 7 

Time Complexity: O(N), where N is the number of nodes in the binary tree, as we need to visit each node once.

Space Complexity: O(N), where N is the maximum number of nodes at any level in the binary tree, as we need to store the horizontal distance of each node from the root node. Additionally, we need to store the nodes in the queue, which can have at most N nodes in the worst case when the tree is a complete binary tree.