Level Order Traversal of BST - c

Question

My program is not giving the desired output. Pls check. What I am doing is, I am first building the queue and then printing every node in the order mentioned in the queue.
The desired output should be F D J B E G K A C I H. The output I am getting is F D J B A C.
#include <stdio.h>
#include <stdlib.h>
struct node
{
char data;
struct node *left;
struct node *right;
};
struct queue
{
struct node *root;
struct queue *next;
};
struct queue *head;
struct node* newnode(char c)
{
struct node *n = (struct node*)malloc(sizeof(struct node));
n->data = c;
n->left = NULL;
n->right = NULL;
return n;
}
void enqueue(struct node *tree)
{
if(head == NULL)
{
struct queue *n = (struct queue*)malloc(sizeof(struct queue));
n->root = tree;
n->next = NULL;
head = n;
}
else
{
struct queue *p = head;
while(p->next != NULL)
{
p = p->next;
}
struct queue *n = (struct queue*)malloc(sizeof(struct queue));
n->root = tree;
n->next = NULL;
p->next = n;
}
}
void traverse(struct node *tree)
{
if(tree != NULL)
{
enqueue(tree->left);
enqueue(tree->right);
traverse(tree->left);
traverse(tree->right);
}
}
void display()
{
struct queue *p = head;
while(p->next != NULL)
{
printf("%c ",p->root->data);
p = p->next;
}
printf("%c \n",p->root->data);
}
int main()
{
struct node *root = newnode('F');
root->left = newnode('D');
root->right = newnode('J');
root->left->left = newnode('B');
root->left->right = newnode('E');
root->right->left = newnode('G');
root->right->right = newnode('K');
root->left->left->left = newnode('A');
root->left->left->right = newnode('C');
root->right->left->left = newnode('I');
root->right->left->left->right = newnode('H');
enqueue(root);
traverse(root);
display();
return 0;
}

Answer 1

Several issues in the traverse function:
enqueue(tree->left) will eventually add NULL to the queue, and this will cause problems in the display function, where it is expected that all p have a non-NULL p->root member.
It doesn't perform a level by level traversal. It is more like a depth-first traversal (after traversing direct siblings). In a level order traversal, there is no recursion. You should iterate the queue (lagging behind as it grows), to fetch values for tree.
Here is a correction for traverse:
void traverse(struct node *tree)
{
struct queue *current = head;
while (current != NULL)
{
tree = current->root;
if (tree->left != NULL) enqueue(tree->left);
if (tree->right != NULL) enqueue(tree->right);
current = current->next; // Walk along the queue while it is being built
}
}