# binary tree level traversal

To perform a level order traversal on a binary tree in C++, you can use a queue data structure. Here are the steps involved:

- Create an empty queue and push the root node onto it.
- Start a loop until the queue becomes empty.
- Inside the loop, pop the front element from the queue and print its value.
- If the popped element has a left child, push it onto the queue.
- If the popped element has a right child, push it onto the queue.
- Repeat steps 3 to 5 until the queue becomes empty.

This algorithm ensures that the elements are traversed level by level, from left to right, starting from the root node. By using a queue, we can keep track of the elements at each level and process them in the desired order.

Here is an example implementation in C++:

```
#include <iostream>
#include <queue>
struct Node {
int value;
Node* left;
Node* right;
Node(int val) {
value = val;
left = nullptr;
right = nullptr;
}
};
void levelOrderTraversal(Node* root) {
if (root == nullptr)
return;
std::queue<Node*> q;
q.push(root);
while (!q.empty()) {
Node* curr = q.front();
q.pop();
std::cout << curr->value << " ";
if (curr->left != nullptr)
q.push(curr->left);
if (curr->right != nullptr)
q.push(curr->right);
}
}
int main() {
// Create a binary tree
Node* root = new Node(1);
root->left = new Node(2);
root->right = new Node(3);
root->left->left = new Node(4);
root->left->right = new Node(5);
// Perform level order traversal
levelOrderTraversal(root);
return 0;
}
```

This program creates a binary tree with values 1, 2, 3, 4, and 5. It then performs a level order traversal on the tree, printing the values in the order they are visited. The output will be: 1 2 3 4 5.