class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(!root) return res;

        queue <TreeNode *> q;

        q.push(root);

        while(!q.empty()){
            int levelsize = q.size();

            vector<int> level;
            for(int i = 0 ;i < levelsize ; i++){
                TreeNode* node = q.front() ;
                q.pop();
                level.push_back(node->val);

                if(node->left) q.push(node->left);
                if(node->right) q.push(node->right);
            }
            res.push_back(level);
        }

        return res;   
    }
};

Time Complexity

• O(N) — where N is the number of nodes in the tree.
• Reason:
  • Every node is enqueued once and dequeued once.
  • We also process each node’s value exactly one time.

Space Complexity

• O(N) in the worst case.
• Reason:
  • The queue can hold up to an entire level of the tree.
  • In the worst case (a completely balanced tree), the last level may have N/2 nodes → O(N) space.
  • The result res also stores all node values → O(N) extra space.

https://leetcode.com/problems/binary-tree-level-order-traversal/

https://takeuforward.org/tree-series/top-tree-interview-questions-structured-path-with-video-solutions/