# Binary Tree Level Order Traversal LeetCode Solution

Here, We see Binary Tree Level Order Traversal LeetCode Solution. This Leetcode problem is done in many programming languages like C++, Java, JavaScript, Python, etc. with different approaches.

# List of all LeetCode Solution

## Problem Statement

Given the `root` of a binary tree, return the level order traversal of its nodes’ values. (i.e., from left to right, level by level).

Example 1:

Input: root = [3,9,20,null,null,15,7]
Output: [[3],[9,20],[15,7]]

Example 2:
Input: root = [1]
Output: [[1]]

Example 3:
Input: root = []
Output: []

## Binary Tree Level Order Traversal LeetCode Solution C++

``````class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>>ans;
if(root==NULL)return ans;
queue<TreeNode*>q;
q.push(root);
while(!q.empty()){
int s=q.size();
vector<int>v;
for(int i=0;i<s;i++){
TreeNode *node=q.front();
q.pop();
if(node->left!=NULL)q.push(node->left);
if(node->right!=NULL)q.push(node->right);
v.push_back(node->val);
}
ans.push_back(v);
}
return ans;
}
};```Code language: PHP (php)```

## Binary Tree Level Order Traversal LeetCode Solution Java

``````class Solution {
public List<List<Integer>> levelOrder(TreeNode root)
{
List<List<Integer>>al=new ArrayList<>();
pre(root,0,al);
return al;
}
public static void pre(TreeNode root,int l,List<List<Integer>>al)
{
if(root==null)
return;
if(al.size()==l)
{
List<Integer>li=new ArrayList<>();
}
else
pre(root.left,l+1,al);
pre(root.right,l+1,al);
}
}```Code language: PHP (php)```

## Binary Tree Level Order Traversal Solution JavaScript

``````var levelOrder = function(root) {
let q = [root], ans = []
while (q[0]) {
let qlen = q.length, row = []
for (let i = 0; i < qlen; i++) {
let curr = q.shift()
row.push(curr.val)
if (curr.left) q.push(curr.left)
if (curr.right) q.push(curr.right)
}
ans.push(row)
}
return ans
};```Code language: JavaScript (javascript)```

## Binary Tree Level Order Traversal SolutionPython

``````class Solution(object):
def levelOrder(self, root):
if not root:
return []
Q = deque([root])
levels = [[root.val]]
temp = deque()
while Q:
node = Q.popleft()
if node.left: temp.append(node.left)
if node.right: temp.append(node.right)
if not Q:
if temp:
levels.append([n.val for n in temp])
Q = temp
temp = deque()
return levels``````
Scroll to Top