#include <stdio.h>
#include <stdlib.h>
#pragma warning (disable:4996)
// Define the TreeNode structure
typedef struct TreeNode {
int value;
struct TreeNode* left;
struct TreeNode* right;
} TreeNode;
// Define a Queue structure for level-order traversal
typedef struct QueueNode {
TreeNode* treenode;
struct QueueNode* next;
} QueueNode;
typedef struct {
QueueNode* front;
QueueNode* rear;
} Queue;
// Function to create a new TreeNode
TreeNode* newTreeNode(int value) {
if (value == -1) {
return NULL;
}
TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
node->value = value;
node->left = node->right = NULL;
return node;
}
// Queue functions
Queue* createQueue() {
Queue* queue = (Queue*)malloc(sizeof(Queue));
queue->front = queue->rear = NULL;
return queue;
}
void enqueue(Queue* queue, TreeNode* node) {
QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
newNode->treenode = node;
newNode->next = NULL;
if (queue->rear == NULL) {
queue->front = queue->rear = newNode;
return;
}
queue->rear->next = newNode;
queue->rear = newNode;
}
TreeNode* dequeue(Queue* queue) {
if (queue->front == NULL) {
return NULL;
}
QueueNode* temp = queue->front;
TreeNode* node = temp->treenode;
queue->front = queue->front->next;
if (queue->front == NULL) {
queue->rear = NULL;
}
free(temp);
return node;
}
int isEmpty(Queue* queue) {
return queue->front == NULL;
}
// Function to build the binary tree
TreeNode* buildTree(int nodes[], int size) {
if (size == 0) return NULL;
TreeNode** tree = (TreeNode**)malloc(size * sizeof(TreeNode*));
for (int i = 0; i < size; i++) {
tree[i] = newTreeNode(nodes[i]);
}
Queue* queue = createQueue();
int nextNode = 1;
for (int i = 0; i < size; i++) {
if (tree[i] != NULL) {
if (nextNode < size && tree[nextNode] != NULL) {
tree[i]->left = tree[nextNode++];
}
else {
nextNode++;
}
if (nextNode < size && tree[nextNode] != NULL) {
tree[i]->right = tree[nextNode++];
}
else {
nextNode++;
}
enqueue(queue, tree[i]);
}
}
TreeNode* root = tree[0];
free(tree);
free(queue);
return root;
}
// Function to perform level order traversal
void levelOrderTraversal(TreeNode* root) {
if (root == NULL) return;
Queue* queue = createQueue();
enqueue(queue, root);
while (!isEmpty(queue)) {
int levelSize = 0;
Queue* tempQueue = createQueue();
while (!isEmpty(queue)) {
TreeNode* current = dequeue(queue);
if (levelSize++ > 0) printf(" ");
printf("%d", current->value);
if (current->left) enqueue(tempQueue, current->left);
if (current->right) enqueue(tempQueue, current->right);
}
free(queue);
queue = tempQueue;
if (!isEmpty(queue)) printf(" ,");
}
free(queue);
}
int main() {
int n;
//printf("Enter number of nodes: ");
scanf("%d", &n);
int* nodes = (int*)malloc(n * sizeof(int));
//printf("Enter the node values (-1 for NULL): ");
for (int i = 0; i < n; i++) {
scanf("%d", &nodes[i]);
}
TreeNode* root = buildTree(nodes, n);
levelOrderTraversal(root);
free(nodes);
printf("\n");
return 0;
}