Related Articles
Print Right View of a Binary Tree
• Difficulty Level : Medium
• Last Updated : 22 Jun, 2021

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.

```Right view of following tree is 1 3 7 8

1
/     \
2        3
/   \     /  \
4     5   6    7
\
8```

The problem can be solved using simple recursive traversal. We can keep track of level of a node by passing a parameter to all recursive calls. The idea is to keep track of maximum level also. And traverse the tree in a manner that right subtree is visited before left subtree. Whenever we see a node whose level is more than maximum level so far, we print the node because this is the last node in its level (Note that we traverse the right subtree before left subtree). Following is the implementation of this approach.

C++

 `// C++ program to print right view of Binary Tree``#include ``using` `namespace` `std;` `struct` `Node``{``    ``int` `data;``    ``struct` `Node *left, *right;``};` `// A utility function to``// create a new Binary Tree Node``struct` `Node *newNode(``int` `item)``{``    ``struct` `Node *temp = (``struct` `Node *)``malloc``(``                          ``sizeof``(``struct` `Node));``    ``temp->data = item;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}` `// Recursive function to print``// right view of a binary tree.``void` `rightViewUtil(``struct` `Node *root,``                   ``int` `level, ``int` `*max_level)``{``    ``// Base Case``    ``if` `(root == NULL) ``return``;` `    ``// If this is the last Node of its level``    ``if` `(*max_level < level)``    ``{``        ``cout << root->data << ``"\t"``;``        ``*max_level = level;``    ``}` `    ``// Recur for right subtree first,``    ``// then left subtree``    ``rightViewUtil(root->right, level + 1, max_level);``    ``rightViewUtil(root->left, level + 1, max_level);``}` `// A wrapper over rightViewUtil()``void` `rightView(``struct` `Node *root)``{``    ``int` `max_level = 0;``    ``rightViewUtil(root, 1, &max_level);``}` `// Driver Code``int` `main()``{``    ``struct` `Node *root = newNode(1);``    ``root->left = newNode(2);``    ``root->right = newNode(3);``    ``root->left->left = newNode(4);``    ``root->left->right = newNode(5);``    ``root->right->left = newNode(6);``    ``root->right->right = newNode(7);``    ``root->right->left->right = newNode(8);` `    ``rightView(root);` `    ``return` `0;``}` `// This code is contributed by SHUBHAMSINGH10`

C

 `// C program to print right view of Binary Tree``#include``#include` `struct` `Node``{``    ``int` `data;``    ``struct` `Node *left, *right;``};` `// A utility function to create a new Binary Tree Node``struct` `Node *newNode(``int` `item)``{``    ``struct` `Node *temp =  (``struct` `Node *)``malloc``(``sizeof``(``struct` `Node));``    ``temp->data = item;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}` `// Recursive function to print right view of a binary tree.``void` `rightViewUtil(``struct` `Node *root, ``int` `level, ``int` `*max_level)``{``    ``// Base Case``    ``if` `(root==NULL)  ``return``;` `    ``// If this is the last Node of its level``    ``if` `(*max_level < level)``    ``{``        ``printf``(``"%d\t"``, root->data);``        ``*max_level = level;``    ``}` `    ``// Recur for right subtree first, then left subtree``    ``rightViewUtil(root->right, level+1, max_level);``    ``rightViewUtil(root->left, level+1, max_level);``}` `// A wrapper over rightViewUtil()``void` `rightView(``struct` `Node *root)``{``    ``int` `max_level = 0;``    ``rightViewUtil(root, 1, &max_level);``}` `// Driver Program to test above functions``int` `main()``{``    ``struct` `Node *root = newNode(1);``    ``root->left = newNode(2);``    ``root->right = newNode(3);``    ``root->left->left = newNode(4);``    ``root->left->right = newNode(5);``    ``root->right->left = newNode(6);``    ``root->right->right = newNode(7);``    ``root->right->left->right = newNode(8);` `    ``rightView(root);` `    ``return` `0;``}`

Java

 `// Java program to print right view of binary tree` `// A binary tree node``class` `Node {` `    ``int` `data;``    ``Node left, right;` `    ``Node(``int` `item) {``        ``data = item;``        ``left = right = ``null``;``    ``}``}` `// class to access maximum level by reference``class` `Max_level {` `    ``int` `max_level;``}` `class` `BinaryTree {` `    ``Node root;``    ``Max_level max = ``new` `Max_level();` `    ``// Recursive function to print right view of a binary tree.``    ``void` `rightViewUtil(Node node, ``int` `level, Max_level max_level) {` `        ``// Base Case``        ``if` `(node == ``null``)``            ``return``;` `        ``// If this is the last Node of its level``        ``if` `(max_level.max_level < level) {``            ``System.out.print(node.data + ``" "``);``            ``max_level.max_level = level;``        ``}` `        ``// Recur for right subtree first, then left subtree``        ``rightViewUtil(node.right, level + ``1``, max_level);``        ``rightViewUtil(node.left, level + ``1``, max_level);``    ``}` `    ``void` `rightView()``    ``{``        ``rightView(root);``    ``}` `    ``// A wrapper over rightViewUtil()``    ``void` `rightView(Node node) {` `        ``rightViewUtil(node, ``1``, max);``    ``}` `    ``// Driver program to test the above functions``    ``public` `static` `void` `main(String args[]) {``        ``BinaryTree tree = ``new` `BinaryTree();``        ``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.left = ``new` `Node(``6``);``        ``tree.root.right.right = ``new` `Node(``7``);``        ``tree.root.right.left.right = ``new` `Node(``8``);``        ` `        ``tree.rightView();` `        ``}``}` `// This code has been contributed by Mayank Jaiswal`

Python

 `# Python program to print right view of Binary Tree` `# A binary tree node``class` `Node:``    ``# A constructor to create a new Binary tree Node``    ``def` `__init__(``self``, item):``        ``self``.data ``=` `item``        ``self``.left ``=` `None``        ``self``.right ``=` `None``    ` `# Recursive function to print right view of Binary Tree``# used max_level as reference list ..only max_level[0]``# is helpful to us``def` `rightViewUtil(root, level, max_level):``    ` `    ``# Base Case``    ``if` `root ``is` `None``:``        ``return``    ` `    ``# If this is the last node of its level``    ``if` `(max_level[``0``] < level):``        ``print` `"%d   "` `%``(root.data),``        ``max_level[``0``] ``=` `level` `    ``# Recur for right subtree first, then left subtree``    ``rightViewUtil(root.right, level``+``1``, max_level)``    ``rightViewUtil(root.left, level``+``1``, max_level)` `def` `rightView(root):``    ``max_level ``=` `[``0``]``    ``rightViewUtil(root, ``1``, max_level)`  `# Driver program to test above function``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``)` `rightView(root)` `# This code is contributed by Nikhil Kumar Singh(nickzuck_007)`

C#

 `using` `System;` `// C# program to print right view of binary tree` `// A binary tree node``public` `class` `Node``{` `    ``public` `int` `data;``    ``public` `Node left, right;` `    ``public` `Node(``int` `item)``    ``{``        ``data = item;``        ``left = right = ``null``;``    ``}``}` `// class to access maximum level by reference``public` `class` `Max_level``{` `    ``public` `int` `max_level;``}` `public` `class` `BinaryTree``{` `    ``public` `Node root;``    ``public` `Max_level max = ``new` `Max_level();` `    ``// Recursive function to print right view of a binary tree.``    ``public` `virtual` `void` `rightViewUtil(Node node, ``int` `level,``                                        ``Max_level max_level)``    ``{` `        ``// Base Case``        ``if` `(node == ``null``)``        ``{``            ``return``;``        ``}` `        ``// If this is the last Node of its level``        ``if` `(max_level.max_level < level)``        ``{``            ``Console.Write(node.data + ``" "``);``            ``max_level.max_level = level;``        ``}` `        ``// Recur for right subtree first, then left subtree``        ``rightViewUtil(node.right, level + 1, max_level);``        ``rightViewUtil(node.left, level + 1, max_level);``    ``}` `    ``public` `virtual` `void` `rightView()``    ``{``        ``rightView(root);``    ``}` `    ``// A wrapper over rightViewUtil()``    ``public` `virtual` `void` `rightView(Node node)``    ``{` `        ``rightViewUtil(node, 1, max);``    ``}` `    ``// Driver program to test the above functions``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``BinaryTree tree = ``new` `BinaryTree();``        ``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.left = ``new` `Node(6);``        ``tree.root.right.right = ``new` `Node(7);``        ``tree.root.right.left.right = ``new` `Node(8);` `        ``tree.rightView();` `    ``}``}` `// This code is contributed by Shrikant13`

Output:

`1      3      7     8 `

Right view of Binary Tree using Queue
Time Complexity: The function does a simple traversal of the tree, so the complexity is O(n).

Method 2: In this method, 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 last node at every level. Below is the implementation of above approach:

C++

 `// C++ program to print left view of``// Binary Tree` `#include ``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 == NULL)``        ``return``;` `    ``queue q;``    ``q.push(root);` `    ``while` `(!q.empty()) {``        ``// get number of nodes for each level``        ``int` `n = q.size();` `        ``// traverse all the nodes of the current level``        ``while` `(n--) {` `            ``Node* x = q.front();``            ``q.pop();` `            ``// print the last node of each level``            ``if` `(n == 0) {``                ``cout << x->data << ``" "``;``            ``}``            ``// if left child is not null push it into the``            ``// stack``            ``if` `(x->left)``                ``q.push(x->left);``            ``// if right child is not null push it into the``            ``// stack``            ``if` `(x->right)``                ``q.push(x->right);``        ``}``    ``}``}` `// Driver code``int` `main()``{``    ``// Let's construct the tree as``    ``// shown in example` `    ``Node* root = newNode(1);``    ``root->left = newNode(2);``    ``root->right = newNode(3);``    ``root->left->left = newNode(4);``    ``root->left->right = newNode(5);``    ``root->right->left = newNode(6);``    ``root->right->right = newNode(7);``    ``root->right->left->right = newNode(8);` `    ``printRightView(root);``}` `// This code is contributed by``// Snehasish Dhar`

Output:

`1 3 7 8`

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