GFG App
Open App
Browser
Continue

# Print Right View of a Binary Tree

Given a Binary Tree, print the Right view of it.

The right view of a Binary Tree is a set of nodes visible when the tree is visited from the Right side.

Examples:

Input:
1
/     \
2        3
/   \       /  \
4     5   6    7
\
8
Output: Right view of the tree is 1 3 7 8

Input:
1
/
8
/
7
Output: Right view of the tree is 1 8 7

Recommended Practice

## Right View of a Binary Tree using Recursion:

The idea is to use recursion and keep track of the maximum level also. And traverse the tree in a manner that the right subtree is visited before the left subtree.

Follow the steps below to solve the problem:

• Perform Postorder traversal to get the rightmost node first
• Maintain a variable name max_level which will store till which it prints the right view
• While traversing the tree in a postorder manner if the current level is greater than max_level then print the current node and update max_level by the current level

Below is the implementation of the above 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->right->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`

## Javascript

 ``

Output

`1    3    7    8    `

Right view of Binary Tree using Queue
Time Complexity: O(N), Traversing the Tree having N nodes
Auxiliary Space: O(N), Function Call stack space in the worst case.

## Right View of a Binary Tree using Level Order Traversal:

The idea is to use Level Order Traversal as the last node every level gives the right view of the binary tree.

Follow the steps below to solve the problem:

• Perform level order traversal on the tree
• At every level print the last node of that 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` `            ``// queue` `            ``if` `(x->left)` `                ``q.push(x->left);` `            ``// if right child is not null push it into the` `            ``// queue` `            ``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`

## Java

 `// JAVA program to print right view of` `// Binary Tree`   `import` `java.io.*;` `import` `java.util.LinkedList;` `import` `java.util.Queue;`   `// A Binary Tree Node` `class` `Node {` `    ``int` `data;` `    ``Node left, right;` `    ``public` `Node(``int` `d)` `    ``{` `        ``data = d;` `        ``left = right = ``null``;` `    ``}` `}`   `class` `BinaryTree {` `    ``Node root;`   `    ``// function to print Right view of` `    ``// binary tree` `    ``void` `rightView(Node root)` `    ``{` `        ``if` `(root == ``null``) {` `            ``return``;` `        ``}`   `        ``Queue q = ``new` `LinkedList<>();` `        ``q.add(root);`   `        ``while` `(!q.isEmpty()) {`   `            ``// get number of nodes for each level` `            ``int` `n = q.size();`   `            ``// traverse all the nodes of the current level` `            ``for` `(``int` `i = ``0``; i < n; i++) {` `                ``Node curr = q.peek();` `                ``q.remove();`   `                ``// print the last node of each level` `                ``if` `(i == n - ``1``) {` `                    ``System.out.print(curr.data);` `                    ``System.out.print(``" "``);` `                ``}`   `                ``// if left child is not null add it into` `                ``// the` `                ``// queue` `                ``if` `(curr.left != ``null``) {` `                    ``q.add(curr.left);` `                ``}`   `                ``// if right child is not null add it into` `                ``// the` `                ``// queue` `                ``if` `(curr.right != ``null``) {` `                    ``q.add(curr.right);` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``// Let's construct the tree as` `        ``// shown in example` `        ``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(tree.root);` `    ``}` `}`   `// This code is contributed by Biswajit Rajak`

## Python3

 `# Python3 program to print right` `# view of Binary Tree` `from` `collections ``import` `deque`   `# A binary tree node`     `class` `Node:`   `    ``# A constructor to create a new` `    ``# Binary tree Node` `    ``def` `__init__(``self``, val):` `        ``self``.data ``=` `val` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# Function to print Right view of` `# binary tree`     `def` `rightView(root):`   `    ``if` `root ``is` `None``:` `        ``return`   `    ``q ``=` `deque()` `    ``q.append(root)`   `    ``while` `q:`   `        ``# Get number of nodes for each level` `        ``n ``=` `len``(q)`   `        ``# Traverse all the nodes of the` `        ``# current level`   `        ``while` `n > ``0``:` `            ``n ``-``=` `1`   `            ``# Get the front node in the queue` `            ``node ``=` `q.popleft()`   `            ``# Print the last node of each level` `            ``if` `n ``=``=` `0``:` `                ``print``(node.data, end``=``" "``)`   `            ``# If left child is not null push it` `            ``# into the queue` `            ``if` `node.left:` `                ``q.append(node.left)`   `            ``# If right child is not null push` `            ``# it into the queue` `            ``if` `node.right:` `                ``q.append(node.right)`   `# Driver code`     `# Let's construct the tree as` `# shown in example` `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 Pulkit Pansari`

## C#

 `// C# program to print right view of` `// Binary Tree` `using` `System;` `using` `System.Collections.Generic;`   `// A Binary Tree Node` `public` `class` `Node {` `    ``public` `int` `data;` `    ``public` `Node left, right;` `    ``public` `Node(``int` `d)` `    ``{` `        ``data = d;` `        ``left = right = ``null``;` `    ``}` `}`   `public` `class` `BinaryTree {` `    ``public` `Node root;`   `    ``// function to print Right view of` `    ``// binary tree` `    ``public` `void` `rightView(Node root)` `    ``{` `        ``if` `(root == ``null``) {` `            ``return``;` `        ``}`   `        ``Queue q = ``new` `Queue();` `        ``q.Enqueue(root);`   `        ``while` `(q.Count != 0) {`   `            ``// get number of nodes for each level` `            ``int` `n = q.Count;`   `            ``// traverse all the nodes of the current level` `            ``for` `(``int` `i = 0; i < n; i++) {` `                ``Node curr = q.Peek();` `                ``q.Dequeue();`   `                ``// print the last node of each level` `                ``if` `(i == n - 1) {` `                    ``Console.Write(curr.data);` `                    ``Console.Write(``" "``);` `                ``}`   `                ``// if left child is not null add it into` `                ``// the` `                ``// queue` `                ``if` `(curr.left != ``null``) {` `                    ``q.Enqueue(curr.left);` `                ``}`   `                ``// if right child is not null add it into` `                ``// the` `                ``// queue` `                ``if` `(curr.right != ``null``) {` `                    ``q.Enqueue(curr.right);` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{` `        ``// Let's construct the tree as` `        ``// shown in example` `        ``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(tree.root);` `    ``}` `}`   `// This code is contributed by jana_sayantan.`

## Javascript

 ``

Output

`1 3 7 8 `

Time Complexity: O(N), where N is the number of nodes in the binary tree.
Auxiliary Space: O(N) since using auxiliary space for queue

### Right View of a Binary Tree using Morris Traversal:

Follow the Steps to implement the approach:

1. Initialize an empty vector res to hold the result.
2. Initialize a pointer curr to the root of the binary tree.
3. While curr is not null, do the following:
If curr has no right child:
Add the value of curr to res.
Set curr to its right child.
Otherwise:
Find the inorder successor of curr by initializing a pointer next to the right child of curr, and then repeatedly moving left until next has no left child or its left child is equal to curr.
If next has no left child:
Add the value of curr to res.
Set the left child of next to curr.
Set curr to its right child.
Otherwise:
Set the left child of next to null.
Set curr to its left child.
4. Return res, which contains the last node at each level of the binary tree as seen from the right side.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the morris traversal approach` `#include ` `#include `   `using` `namespace` `std;`   `// Definition for a binary tree node` `struct` `TreeNode {` `    ``int` `val;` `    ``TreeNode* left;` `    ``TreeNode* right;` `    ``TreeNode(``int` `x)` `        ``: val(x)` `        ``, left(NULL)` `        ``, right(NULL)` `    ``{` `    ``}` `};`   `vector<``int``> rightSideView(TreeNode* root)` `{` `    ``vector<``int``> res;` `    ``TreeNode* curr = root;` `    ``while` `(curr) {` `        ``if` `(!curr->right) { ``// if there is no right child ,` `                            ``// add the current node's value` `                            ``// to the vector` `            ``res.push_back(curr->val);` `            ``curr = curr->right; ``// move to the right child` `        ``}` `        ``else` `{ ``// if there is a right child` `            ``TreeNode* next` `                ``= curr->right; ``// set the next node to the` `                               ``// right child` `            ``while` `(next->left` `                   ``&& next->left` `                          ``!= curr) { ``// traverse the left` `                                     ``// subtree of the right` `                                     ``// child untill a leaf` `                                     ``// node or the current` `                                     ``// node is reached` `                ``next = next->left;` `            ``}`   `            ``if` `(!next->left) { ``// if the left child of the` `                               ``// next node is NULL` `                ``res.push_back(curr->val);` `                ``next->left = curr;` `                ``curr = curr->right;` `            ``}` `            ``else` `{` `                ``next->left = NULL;` `                ``curr = curr->left;` `            ``}` `        ``}` `    ``}` `    ``return` `res;` `}` `// Driver code` `int` `main()` `{` `    ``TreeNode* root = ``new` `TreeNode(1);` `    ``root->left = ``new` `TreeNode(2);` `    ``root->right = ``new` `TreeNode(3);` `    ``root->left->left = ``new` `TreeNode(4);` `    ``root->left->right = ``new` `TreeNode(5);` `    ``root->right->left = ``new` `TreeNode(6);` `    ``root->right->right = ``new` `TreeNode(7);` `    ``root->right->right->right = ``new` `TreeNode(8);` `    ``vector<``int``> res = rightSideView(root);` `    ``for` `(``int` `i : res) {` `        ``cout << i << ``" "``;` `    ``}` `    ``cout << endl;`   `    ``return` `0;` `}` `// This code is contributed by Veerendra_Singh_Rajpoot`

## Python3

 `# Python code to implement the morris traversal approach`   `# Definition for a binary tree node`     `class` `TreeNode:` `    ``def` `__init__(``self``, x):` `        ``self``.val ``=` `x` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`     `def` `rightSideView(root):` `    ``res ``=` `[]` `    ``curr ``=` `root` `    ``while` `curr:` `        ``if` `not` `curr.right:  ``# if there is no right child,` `                            ``# add the current node's value` `                            ``# to the vector` `            ``res.append(curr.val)` `            ``curr ``=` `curr.right  ``# move to the right child` `        ``else``:  ``# if there is a right child` `            ``next` `=` `curr.right  ``# set the next node to the` `            ``# right child` `            ``while` `next``.left ``and` `next``.left !``=` `curr:` `                ``# traverse the left subtree of the right` `                ``# child untill a leaf node or the current` `                ``# node is reached` `                ``next` `=` `next``.left`   `            ``if` `not` `next``.left:  ``# if the left child of the` `                              ``# next node is NULL` `                ``res.append(curr.val)` `                ``next``.left ``=` `curr` `                ``curr ``=` `curr.right` `            ``else``:` `                ``next``.left ``=` `None` `                ``curr ``=` `curr.left` `    ``return` `res`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``root ``=` `TreeNode(``1``)` `    ``root.left ``=` `TreeNode(``2``)` `    ``root.right ``=` `TreeNode(``3``)` `    ``root.left.left ``=` `TreeNode(``4``)` `    ``root.left.right ``=` `TreeNode(``5``)` `    ``root.right.left ``=` `TreeNode(``6``)` `    ``root.right.right ``=` `TreeNode(``7``)` `    ``root.right.right.right ``=` `TreeNode(``8``)` `    ``res ``=` `rightSideView(root)` `    ``for` `i ``in` `res:` `        ``print``(i, end``=``" "``)` `    ``print``()` `# Contributed by adityasha4x71`

## Javascript

 `// Javascript code addition `   `// Definition for a binary tree node` `class TreeNode {` `    ``constructor(val) {` `        ``this``.val = val;` `        ``this``.left = ``null``;` `        ``this``.right = ``null``;` `    ``}` `}`   `function` `rightSideView(root) {` `    ``const res = [];` `    ``let curr = root;` `    ``let n = 4;` `    ``while` `(curr) {` `        ``if` `(!curr.right) { ``// if there is no right child ,` `                            ``// add the current node's value` `                            ``// to the array` `            ``res.push(curr.val);` `            ``curr = curr.left; ``// move to the left child` `        ``}` `        ``else` `{ ``// if there is a right child` `            ``let next = curr.right; ``// set the next node to the` `                                    ``// right child` `            ``while` `(next.left && next.left !== curr) { ``// traverse the left` `                                                      ``// subtree of the right` `                                                      ``// child untill a leaf` `                                                      ``// node or the current` `                                                      ``// node is reached` `                ``next = next.left;` `            ``}`   `            ``if` `(!next.left) { ``// if the left child of the` `                               ``// next node is NULL` `                ``res.push(curr.val);` `                ``next.left = curr;` `                ``curr = curr.right;` `            ``}` `            ``else` `{` `                ``next.left = ``null``;` `                ``curr = curr.left;` `            ``}` `        ``}` `    ``}` `    ``return` `res.slice(0, n);` `}`   `// Driver code` `const root = ``new` `TreeNode(1);` `root.left = ``new` `TreeNode(2);` `root.right = ``new` `TreeNode(3);` `root.left.left = ``new` `TreeNode(4);` `root.left.right = ``new` `TreeNode(5);` `root.right.left = ``new` `TreeNode(6);` `root.right.right = ``new` `TreeNode(7);` `root.right.right.right = ``new` `TreeNode(8);`   `const res = rightSideView(root);` `console.log(res);`   `// The code is contributed by Arushi Goel. `

Output

`1 3 7 8 `

Time Complexity: O(n) , The time complexity of the Morris Traversal approach is O(n), where n is the number of nodes in the binary tree. This is because we visit each node exactly twice (once when we find its inorder predecessor, and once when we visit it from its inorder predecessor).

Auxiliary Space:  O(1) , The space complexity of the Morris Traversal approach is O(1), because we only use a constant amount of extra space for the res, curr, and next pointers. We do not use any additional data structures or recursive function calls that would increase the space complexity.