Right view of Binary Tree using Queue

Given a Binary Tree, print Right view of it. Right view of a Binary Tree is set of nodes visible when tree is visited from Right side.

Examples:

Input : 
              10
            /     \
          2         3
        /   \    /    \
       7     8  12     15
                      /
                    14
Output : 10 3 15 14
The output nodes are the rightmost
nodes of their respective levels.



We have already discussed recursive solution for right view. In this post, level order traversal based solution is discussed.

If we observe carefully, we will see that our main task is to print the right most node of every level. So, we will do a level order traversal on the tree and print the rightmost node at every level.

Below is the implementation of above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to print right view of
// Binary Tree
  
#include<bits/stdc++.h>
using namespace std;
  
// A Binary Tree Node
struct Node
{
    int data;
    struct Node *left, *right;
};
  
// Utility function to create a new tree node
Node* newNode(int data)
{
    Node *temp = new Node;
    temp->data = data;
    temp->left = temp->right = NULL;
    return temp;
}
  
// function to print right view of
// binary tree
void printRightView(Node* root)
{
    if (!root)
        return;
  
    queue<Node*> q;
    q.push(root);
  
    while (!q.empty())
    {    
        // number of nodes at current level
        int n = q.size();
          
        // Traverse all nodes of current level 
        for(int i = 1; i <= n; i++)
        {
            Node* temp = q.front();
            q.pop();
                  
            // Print the right most element 
            // at the level
            if (i == n)
                cout<<temp->data<<" ";
              
            // Add left node to queue
            if (temp->left != NULL)
                q.push(temp->left);
  
            // Add right node to queue
            if (temp->right != NULL)
                q.push(temp->right);
        }
    }
}    
  
// Driver program to test above functions
int main()
{
    // Let's construct the tree as 
    // shown in example
  
    Node* root = newNode(10);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(7);
    root->left->right = newNode(8);
    root->right->right = newNode(15);
    root->right->left = newNode(12);
    root->right->right->left = newNode(14);
  
    printRightView(root);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to print right view of Binary
// Tree
import java.util.*;
  
public class PrintRightView 
{   
    // Binary tree node
    private static class Node
    {
        int data;
        Node left, right;
  
        public Node(int data) {
            this.data = data;
            this.left = null;
            this.right = null;
        }
    }
      
    // function to print right view of binary tree
    private static void printRightView(Node root) 
    {
        if (root == null)
            return;
              
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
          
        while (!queue.isEmpty()) 
        {   
            // number of nodes at current level
            int n = queue.size();
              
            // Traverse all nodes of current level 
            for (int i = 1; i <= n; i++) {
                Node temp = queue.poll();
                  
                // Print the right most element at 
                // the level
                if (i == n)
                    System.out.print(temp.data + " ");
                  
                // Add left node to queue
                if (temp.left != null)
                    queue.add(temp.left);
                      
                // Add right node to queue
                if (temp.right != null)
                    queue.add(temp.right);
            }
        }
    }
  
    // Driver code
    public static void main(String[] args) 
    {
        // construct binary tree as shown in 
        // above diagram
        Node root = new Node(10);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(7);
        root.left.right = new Node(8);
        root.right.right = new Node(15);
        root.right.left = new Node(12);
        root.right.right.left = new Node(14);
          
        printRightView(root);
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to print right view of 
# Binary Tree
  
# Binary Tree Node 
""" utility that allocates a newNode 
with the given key """
class newNode: 
  
    # Construct to create a newNode 
    def __init__(self, key): 
        self.data = key
        self.left = None
        self.right = None
        self.hd = 0
  
# function to print right view of 
# binary tree 
def printRightView(root):
  
    if (not root): 
        return
  
    q = [] 
    q.append(root) 
  
    while (len(q)): 
          
        # number of nodes at current level 
        n = len(q) 
          
        # Traverse all nodes of current level 
        for i in range(1, n + 1):         
            temp = q[0
            q.pop(0
                  
            # Print the right most element 
            # at the level 
            if (i == n) :
                print(temp.data, end = " " )
              
            # Add left node to queue 
            if (temp.left != None) :
                q.append(temp.left) 
  
            # Add right node to queue 
            if (temp.right != None) :
                q.append(temp.right) 
  
# Driver Code 
if __name__ == '__main__':
  
    root = newNode(10
    root.left = newNode(2
    root.right = newNode(3
    root.left.left = newNode(7
    root.left.right = newNode(8
    root.right.right = newNode(15
    root.right.left = newNode(12
    root.right.right.left = newNode(14)
    printRightView(root)
  
# This code is contributed by
# Shubham Singh(SHUBHAMSINGH10)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to print right view 
// of Binary Tree 
using System;
using System.Collections.Generic;
  
public class PrintRightView 
    // Binary tree node 
    private class Node 
    
        public int data; 
        public Node left, right; 
  
        public Node(int data)
        
            this.data = data; 
            this.left = null
            this.right = null
        
    
      
    // function to print right view of binary tree 
    private static void printRightView(Node root) 
    
        if (root == null
            return
              
        Queue<Node> queue = new Queue<Node>(); 
        queue.Enqueue(root); 
          
        while (queue.Count != 0) 
        
            // number of nodes at current level 
            int n = queue.Count; 
              
            // Traverse all nodes of current level 
            for (int i = 1; i <= n; i++)
            
                Node temp = queue.Dequeue(); 
                  
                // Print the right most element at 
                // the level 
                if (i == n) 
                    Console.Write(temp.data + " "); 
                  
                // Add left node to queue 
                if (temp.left != null
                    queue.Enqueue(temp.left); 
                      
                // Add right node to queue 
                if (temp.right != null
                    queue.Enqueue(temp.right); 
            
        
    
  
    // Driver code 
    public static void Main(String[] args) 
    
        // construct binary tree as shown in 
        // above diagram 
        Node root = new Node(10); 
        root.left = new Node(2); 
        root.right = new Node(3); 
        root.left.left = new Node(7); 
        root.left.right = new Node(8); 
        root.right.right = new Node(15); 
        root.right.left = new Node(12); 
        root.right.right.left = new Node(14); 
        printRightView(root); 
    
  
// This code is contributed 29AjayKumar

chevron_right



Output:

10 3 15 14

Time Complexity: O( n ), where n is the number of nodes in the binary tree.

This article is contributed by Bibhas Abhishek. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up



Article Tags :
Practice Tags :


4


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.