Print Right View of a Binary Tree

// Java program to print right view of binary tree
// using Recursion
import java.util.ArrayList;

class Node {
    int data;
    Node left, right;

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

// Helper function for the right view using Recursion
class GfG {
    static void RecursiveRightView(Node root, int level, 
                  int[] maxLevel, ArrayList<Integer> result) {
        if (root == null) return;

        // If current level is more than max level,
        // this is the first node of that level
        if (level > maxLevel[0]) {
            result.add(root.data);
            maxLevel[0] = level;
        }

        // Traverse right subtree first, then left subtree
        RecursiveRightView(root.right, level + 1,
                          maxLevel, result);
        RecursiveRightView(root.left, level + 1,
                          maxLevel, result);
    }

    // Function to return the right view of the binary tree
    static ArrayList<Integer> rightView(Node root) {
        ArrayList<Integer> result = new ArrayList<>();
        int[] maxLevel = new int[] {-1};
        
        // Start recursion with root at level 0
        RecursiveRightView(root, 0, maxLevel, result);
        
        return result;
    }

    static void printArray(ArrayList<Integer> arr) {
        for (int val : arr) {
            System.out.print(val + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
      
        // Representation of the input tree:
        //         1
        //        / \
        //       2   3
        //           / \   
        //          4   5 
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.right.left = new Node(4);
        root.right.right = new Node(5);

        ArrayList<Integer> result = rightView(root);
        
        printArray(result);
    }
}

// Java program to print right view of Binary
// tree using modified Morris Traversal
import java.util.ArrayList;

class Node {
    int data;
    Node left, right;

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

// Function to return the right view of the binary tree
class GfG {
    
    public static ArrayList<Integer> rightView(Node root) {
        
        // To store the right view nodes
        ArrayList<Integer> res = new ArrayList<>();
        
        // Current level of traversal
        int level = 0;

        // Traverse the tree using modified 
        // Morris Traversal
        while (root != null) {
            
            // If the node has a right child,
            // find the inorder predecessor
            if (root.right != null) {
                Node pred = root.right;
                int backDepth = 1;

                // Find the leftmost node in the
                // right subtree
                while (pred.left != null
                                 && pred.left != root) {
                    pred = pred.left;
                    backDepth++;
                }

                // If threading is not yet established
                if (pred.left == null) {
                    
                    // Add the current node to the view if 
                    // visiting the level for the first time
                    if (res.size() == level) {
                        res.add(root.data);
                    }

                    // Establish the thread and move 
                    // to the right subtree
                    pred.left = root;
                    root = root.right;
                    level++;
                } 
                else {
                    
                    // Threading was already done 
                    // (second visit) remove the thread 
                    // and go to the left subtree
                    pred.left = null;
                    root = root.left;
                    level -= backDepth;
                }
            } 
            else {
                
                // If no right child, process the current 
                // node and move to the left child
                if (res.size() == level) {
                    res.add(root.data);
                }
                
                root = root.left;
                level++;
            }
        }

        return res;
    }

    static void printArray(ArrayList<Integer> arr) {
        for (int val : arr) {
            System.out.print(val + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        
        // Representation of the input tree:
        //         1
        //        / \
        //       2   3
        //          / \
        //         4   5 
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.right.left = new Node(4);
        root.right.right = new Node(5);

        ArrayList<Integer> result = rightView(root);
        
        printArray(result);
    }
}