101102103104105106107108109110111112113114115116117118119120121122123124125126127128129
#include <bits/stdc++.h>
using namespace std;

// Structure for a binary tree node
struct Node {
    int data;
    Node* left;
    Node* right;
    
    Node(int val) {
        data = val;
        left = right = NULL;
    }
};

class Solution {
public:
    // Function to return level order traversal
    vector<vector<int>> levelOrder(Node* root) {
        // Initialize the final 2D vector
        vector<vector<int>> ans;

        // If the tree is empty, return empty vector
        if (!root) return ans;

        // Create a queue to hold tree nodes
        queue<Node*> q;

        // Start with the root node
        q.push(root);

        // Loop until queue is empty
        while (!q.empty()) {
            // Get the number of nodes at the current level
            int size = q.size();

            // Vector to store current level nodes
            vector<int> level;

            // Process all nodes at the current level
            for (int i = 0; i < size; i++) {
                // Get the front node from the queue
                Node* node = q.front();
                q.pop();

                // Add its data to the level vector
                level.push_back(node->data);

                // Enqueue left child if exists
                if (node->left) q.push(node->left);

                // Enqueue right child if exists
                if (node->right) q.push(node->right);
            }

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

        return ans;
    }

    // Function to return the left view
    vector<int> leftView(Node* root) {
        // Get the level order traversal
        vector<vector<int>> levels = levelOrder(root);

        // Vector to store left view
        vector<int> left;

        // Pick first element of each level
        for (auto& level : levels) {
            left.push_back(level[0]);
        }

        return left;
    }

    // Function to return the right view
    vector<int> rightView(Node* root) {
        // Get the level order traversal
        vector<vector<int>> levels = levelOrder(root);

        // Vector to store right view
        vector<int> right;

        // Pick last element of each level
        for (auto& level : levels) {
            right.push_back(level.back());
        }

        return right;
    }
};

// Driver code
int main() {
    // Manually create the binary tree
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->right->right = new Node(5);

    Solution obj;

    // Get level order traversal
    vector<vector<int>> levelOrder = obj.levelOrder(root);
    cout << "Level Order Traversal:\n";
    for (auto& level : levelOrder) {
        for (int val : level) cout << val << " ";
        cout << "\n";
    }

    // Get left view
    vector<int> left = obj.leftView(root);
    cout << "Left View: ";
    for (int val : left) cout << val << " ";
    cout << "\n";

    // Get right view
    vector<int> right = obj.rightView(root);
    cout << "Right View: ";
    for (int val : right) cout << val << " ";
    cout << "\n";

    return 0;
}
1234