120121122123124125126127128129130
using System;
using System.Collections.Generic;

// Definition for a binary tree node.
public class TreeNode
{
    public int data;
    public TreeNode left;
    public TreeNode right;
    // Constructor to initialize the node with a value
    public TreeNode(int val)
    {
        data = val;
        left = null;
        right = null;
    }
}

public class Solution
{
    // Function to return the Right view of the binary tree
    public IList<int> RightSideView(TreeNode root)
    {
        List<int> res = new List<int>();
        // Get the level order traversal of the tree
        List<List<int>> levelTraversal = LevelOrder(root);
        // Iterate through each level and add the last element to the result
        foreach (var level in levelTraversal)
        {
            res.Add(level[level.Count - 1]);
        }
        return res;
    }

    // Function to return the Left view of the binary tree
    public IList<int> LeftSideView(TreeNode root)
    {
        List<int> res = new List<int>();
        // Get the level order traversal of the tree
        List<List<int>> levelTraversal = LevelOrder(root);
        // Iterate through each level and add the first element to the result
        foreach (var level in levelTraversal)
        {
            res.Add(level[0]);
        }
        return res;
    }

    // Function that returns the level order traversal of a binary tree
    private List<List<int>> LevelOrder(TreeNode root)
    {
        List<List<int>> ans = new List<List<int>>();
        // Return an empty list if the tree is empty
        if (root == null)
        {
            return ans;
        }

        // Use a queue to perform level order traversal
        Queue<TreeNode> q = new Queue<TreeNode>();
        q.Enqueue(root);

        while (q.Count > 0)
        {
            int size = q.Count;
            List<int> level = new List<int>();

            // Process each node in the current level
            for (int i = 0; i < size; i++)
            {
                TreeNode top = q.Dequeue();
                level.Add(top.data);

                // Enqueue the left child if it exists
                if (top.left != null)
                {
                    q.Enqueue(top.left);
                }
                // Enqueue the right child if it exists
                if (top.right != null)
                {
                    q.Enqueue(top.right);
                }
            }

            // Add the current level to the result
            ans.Add(level);
        }

        return ans;
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        // Creating a sample binary tree
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(10);
        root.left.left.right = new TreeNode(5);
        root.left.left.right.right = new TreeNode(6);
        root.right = new TreeNode(3);
        root.right.right = new TreeNode(10);
        root.right.left = new TreeNode(9);

        Solution solution = new Solution();

        // Get the Right View traversal
        IList<int> rightView = solution.RightSideView(root);
        Console.Write("Right View Traversal: ");
        foreach (int node in rightView)
        {
            Console.Write(node + " ");
        }
        Console.WriteLine();

        // Get the Left View traversal
        IList<int> leftView = solution.LeftSideView(root);
        Console.Write("Left View Traversal: ");
        foreach (int node in leftView)
        {
            Console.Write(node + " ");
        }
        Console.WriteLine();
    }
}