Print Right View of a Binary Tree

// 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

// 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<Node> 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

import java.util.ArrayList;
import java.util.List;

// Definition for a binary tree node
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

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

public class RightSideView {
    public List<Integer> rightSideView(TreeNode root)
    {
        List<Integer> res = new ArrayList<>();
        TreeNode curr = root;
        int n = 4; // You can set 'n' to any desired value
        while (curr != null) {
            if (curr.right
                == null) { // if there is no right child,
                           // add the current node's value
                           // to the list
                res.add(curr.val);
                curr = curr.left; // move to the left child
            }
            else { // if there is a right child
                TreeNode next
                    = curr.right; // set the next node to
                                  // the right child
                while (
                    next.left != null
                    && next.left
                           != curr) { // traverse the left
                                      // subtree of the
                                      // right child until a
                                      // leaf node or the
                                      // current node is
                                      // reached
                    next = next.left;
                }

                if (next.left
                    == null) { // if the left child of the
                               // next node is null
                    res.add(curr.val);
                    next.left = curr;
                    curr = curr.right;
                }
                else {
                    next.left = null;
                    curr = curr.left;
                }
            }
        }
        return res.subList(0, Math.min(n, res.size()));
    }
    // Driver Code
    public static void main(String[] args)
    {
        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);

        RightSideView rightSideView = new RightSideView();
        List<Integer> res
            = rightSideView.rightSideView(root);
        System.out.println(res);
    }
}
// This code is contributed by Veerendra_Singh_Rajpoot