Binary Tree Level Order Traversal Using Queue in C - c

Question

I am fairly new to C. I started studying data structures and was okay with linked lists, stacks, and queues. Right now I am implementing BST's and they seem to be pretty complicated. Here I tried writing code for Level Order Transversal and I am not getting the required output.
Please help me fix it. It showed no errors. On running the program, I get infinite 'G' as my output. I expected to get all the characters (which I had input in the main function) to be printed in some order.
#include <stdio.h>
#include <stdlib.h>
struct Node
{
char data;
struct Node* right;
struct Node* left;
};
void enq(struct Node* temproot);
struct Node* deq();
struct Node* Insert(struct Node* ,char x);
struct Node* newNode (char data);
void LevelOrder(struct Node* root);
struct Node* front = NULL;
struct Node* rear = NULL;
int main()
{
struct Node* root;
root = NULL;
root = Insert(root,'F');
root = Insert(root,'B');
root = Insert(root,'C');
root = Insert(root,'D');
root = Insert(root,'E');
root = Insert(root,'G');
root = Insert(root,'A');
root = Insert(root,'H');
root = Insert(root,'I');
LevelOrder(root);
return 0;
}
struct Node* Insert(struct Node* root,char x)
{
if (root == NULL)
{
root = newNode(x);
}
else if (x <= root->data)
{
root->left = Insert(root->left, x);
}
else
{
root->right = Insert(root->right,x);
}
return root;
}
struct Node* newNode(char x)
{
struct Node* temp1 = (struct Node*)malloc(sizeof(struct Node));
temp1->data = x;
temp1->right = NULL;
temp1->left = NULL;
return temp1;
}
void enq(struct Node* temproot)
{
struct Node* temp = (struct Node*)malloc(sizeof(struct Node));
temp->data = temproot->data;
temp->right = temp->left= NULL;
if(front == NULL && rear == NULL)
{
front = rear = temp;
return;
}
rear->right = temp;
rear = temp;
}
struct Node* deq()
{
struct Node* temp = front;
if (front == NULL)
{
printf("The queue is empty!");
}
else if (rear == front)
{
front = rear = NULL;
}
else
{
front = front->right;
}
return temp;
}
void LevelOrder(struct Node* root)
{
struct Node* temproot = root;
while(temproot != NULL)
{
printf("%c ", temproot->data);
if(temproot->left != NULL)
{enq(temproot->left);
}
if (temproot->right !=NULL)
{enq(temproot->right);
}
temproot = deq();
}
}

Answer 1

As noted in the comments, you need to enqueue the pointers to the nodes in the tree structures — not the data. You can do this by using the left element to point to the node and the right element to point to the next item in the queue.
In the comments, I said:
I've not tested it, but maybe (just maybe), you need to replace
temp->data = temproot->data;
temp->right = temp->left= NULL;
in enq() with
temp->left = temproot;
temp->right = NULL;
and then in deq() you should have
struct Node *next = temp->left;
free(temp);
return next;
This seems to be the correct prescription. This code has a function dump_BST that dumps the data in the tree for debugging purposes (and an auxilliary function dump_BST_node() that implements a pre-order traversal while printing.
#include <stdio.h>
#include <stdlib.h>
struct Node
{
char data;
struct Node *right;
struct Node *left;
};
void enq(struct Node *temproot);
struct Node *deq(void);
struct Node *Insert(struct Node *, char x);
struct Node *newNode(char data);
void LevelOrder(struct Node *root);
void dump_BST(const char *tag, const struct Node *node);
struct Node *front = NULL;
struct Node *rear = NULL;
int main(void)
{
struct Node *root = NULL;
dump_BST("Empty", root);
root = Insert(root, 'F');
dump_BST("Added F", root);
root = Insert(root, 'B');
dump_BST("Added B", root);
root = Insert(root, 'C');
//dump_BST("Added C", root);
root = Insert(root, 'D');
//dump_BST("Added D", root);
root = Insert(root, 'E');
//dump_BST("Added E", root);
root = Insert(root, 'G');
//dump_BST("Added G", root);
root = Insert(root, 'A');
//dump_BST("Added A", root);
root = Insert(root, 'H');
//dump_BST("Added H", root);
root = Insert(root, 'I');
dump_BST("Added I", root);
LevelOrder(root);
return 0;
}
struct Node *Insert(struct Node *root, char x)
{
if (root == NULL)
{
root = newNode(x);
}
else if (x <= root->data)
{
root->left = Insert(root->left, x);
}
else
{
root->right = Insert(root->right, x);
}
return root;
}
struct Node *newNode(char x)
{
struct Node *temp1 = (struct Node *)malloc(sizeof(struct Node));
temp1->data = x;
temp1->right = NULL;
temp1->left = NULL;
return temp1;
}
void enq(struct Node *temproot)
{
struct Node *temp = (struct Node *)malloc(sizeof(struct Node));
temp->right = NULL;
temp->left = temproot;
temp->data = 'Z';
if (front == NULL && rear == NULL)
{
front = rear = temp;
}
else
{
rear->right = temp;
rear = temp;
}
}
struct Node *deq(void)
{
struct Node *temp = front;
if (front == NULL)
{
printf("The queue is empty!\n");
}
else if (rear == front)
{
front = rear = NULL;
}
else
{
front = front->right;
}
struct Node *next = (temp == NULL) ? NULL : temp->left;
free(temp);
return next;
}
void LevelOrder(struct Node *root)
{
struct Node *temproot = root;
while (temproot != NULL)
{
printf("%c ", temproot->data);
if (temproot->left != NULL)
{
enq(temproot->left);
}
if (temproot->right != NULL)
{
enq(temproot->right);
}
temproot = deq();
}
putchar('\n');
}
static void dump_BST_nodes(const struct Node *node)
{
if (node != NULL)
{
printf("Node: '%c' (ptr = %p, left = %p, right = %p)\n",
node->data, (void *)node, (void *)node->left, (void *)node->right);
dump_BST_nodes(node->left);
dump_BST_nodes(node->right);
}
}
void dump_BST(const char *tag, const struct Node *node)
{
printf("%s:\n", tag);
dump_BST_nodes(node);
printf("%s: end\n", tag);
}
When run, this produces:
Empty:
Empty: end
Added F:
Node: 'F' (ptr = 0x7fc63fc02750, left = 0x0, right = 0x0)
Added F: end
Added B:
Node: 'F' (ptr = 0x7fc63fc02750, left = 0x7fc63fc02770, right = 0x0)
Node: 'B' (ptr = 0x7fc63fc02770, left = 0x0, right = 0x0)
Added B: end
Added I:
Node: 'F' (ptr = 0x7fc63fc02750, left = 0x7fc63fc02770, right = 0x7fc63fc027f0)
Node: 'B' (ptr = 0x7fc63fc02770, left = 0x7fc63fc02810, right = 0x7fc63fc02790)
Node: 'A' (ptr = 0x7fc63fc02810, left = 0x0, right = 0x0)
Node: 'C' (ptr = 0x7fc63fc02790, left = 0x0, right = 0x7fc63fc027b0)
Node: 'D' (ptr = 0x7fc63fc027b0, left = 0x0, right = 0x7fc63fc027d0)
Node: 'E' (ptr = 0x7fc63fc027d0, left = 0x0, right = 0x0)
Node: 'G' (ptr = 0x7fc63fc027f0, left = 0x0, right = 0x7fc63fc02830)
Node: 'H' (ptr = 0x7fc63fc02830, left = 0x0, right = 0x7fc63fc02850)
Node: 'I' (ptr = 0x7fc63fc02850, left = 0x0, right = 0x0)
Added I: end
F B G A C H D I E The queue is empty!
You'll need to clean up the code — the message that the queue is empty is a nuisance, and you won't need the debugging printing. But that does show how I did go about checking the code (the fact that it worked OK the first time through was an unexpected but pleasant bonus).