LevelOrder_CPP.cpp

/* Binary tree - Level Order Traversal */
#include<iostream>
#include<queue>
using namespace std;

struct Node {
	char data;
	Node *left;
	Node *right;
};

// Function to print Nodes in a binary tree in Level order
void LevelOrder(Node *root) {
	if(root == NULL) return;
	queue<Node*> Q;
	Q.push(root);  
	//while there is at least one discovered node
	while(!Q.empty()) {
		Node* current = Q.front();
		Q.pop(); // removing the element at front
		cout<<current->data<<" ";
		if(current->left != NULL) Q.push(current->left);
		if(current->right != NULL) Q.push(current->right);
	}
}
// Function to Insert Node in a Binary Search Tree
Node* Insert(Node *root,char data) {
	if(root == NULL) {
		root = new Node();
		root->data = data;
		root->left = root->right = NULL;
	}
	else if(data <= root->data) root->left = Insert(root->left,data);
	else root->right = Insert(root->right,data);
	return root;
}

int main() {
	/*Code To Test the logic
	  Creating an example tree
	                    M
			   / \
			  B   Q
			 / \   \
			A   C   Z
    */
	Node* root = NULL;
	root = Insert(root,'M'); root = Insert(root,'B');
	root = Insert(root,'Q'); root = Insert(root,'Z'); 
	root = Insert(root,'A'); root = Insert(root,'C');
	//Print Nodes in Level Order. 
	LevelOrder(root);
}

Here is my version of it (note! : I implemented my own version of Queues and all its operations:
#include<stdio.h>
#include<stdlib.h>

struct treeNode
{
int data;
struct treeNode * left;
struct treeNode * right;
};
typedef struct treeNode treeNode ;

struct node
{
treeNode * data;
struct node * next;
};
typedef struct node node;

struct Q{
node * front;
node * rear;
};
typedef struct Q Q;

int isEmpty(Q * queue)
{
return (queue == NULL || queue->front == NULL);
}

Q * enqueue(Q * queue , treeNode * data)
{
if(isEmpty(queue))
{
queue = (Q *)malloc(sizeof(Q));
queue->front = (node *)malloc(sizeof(node));
queue->front->data = data;
queue->front->next = NULL;
queue->rear = queue->front;
return queue;
}
else if(data == NULL) return queue;
else
{
queue->rear->next = (node *)malloc(sizeof(node));
queue->rear->next->data = data;
queue->rear->next->next = NULL;
queue->rear = queue->rear->next;
return queue;
}
}

void dequeue(Q * queue)
{
if(isEmpty(queue)) return;
else
{
node * toFree = queue->front;
queue->front = queue->front->next;
free(toFree);
}
}

node * front( Q * queue)
{
if(isEmpty(queue)) return fprintf(stderr,"can't read from a NULL pointer");
else
{
return queue->front;
}
}

void BreadthFirstTraversal(treeNode * root)
{
if(root == NULL) return;
else
{
Q * queue = NULL;
queue = enqueue(queue,root);
//printf("Queue head : %d ",queue->front->data->data);
printf("\nQueue : ");
while(!isEmpty(queue))
{
node * frontElement = front(queue);
printf(" %d",frontElement->data->data);
queue = enqueue(queue,frontElement->data->left);
queue = enqueue(queue,frontElement->data->right);
dequeue(queue);
}
}
}

void insert(treeNode ** ptrToRoot , int data) //using recursion
{
if(*ptrToRoot == NULL)
{
*ptrToRoot = (treeNode *)malloc(sizeof(treeNode));
(*ptrToRoot)->data = data;
(*ptrToRoot)->left = NULL;
(*ptrToRoot)->right = NULL;
}
else if(data > (*ptrToRoot)->data)
{
insert(&(*ptrToRoot)->right,data);
}
else if(data <= (*ptrToRoot)->data)
{
insert(&(*ptrToRoot)->left,data);
}
}

int main()
{
treeNode *tree = NULL;
insert(&tree,1);
insert(&tree,100);
insert(&tree,-1);
insert(&tree,8);
insert(&tree,6);

BreadthFirstTraversal(tree);  
return 0; 

}

very helpful

Very helpful thank you!

void LevelOrder(struct BstNode* root){
if(root==NULL) return;

Very Hepful

$$\large\textcolor{yellow}{\textsf{JavaScript} \space \color{white}\textsf{Version is here..!}}$$

class Node {
  constructor(data) {
    this.data = data;
    this.left = null;
    this.right = null;
  }

  // Method to insert a node into the Binary Search Tree rooted at this node
  insert(data) {
    if (data <= this.data) {
      this.left === null ? this.left = new Node(data) : this.left.insert(data);
    } else {
      this.right === null ? this.right = new Node(data) : this.right.insert(data);
    }
  }
}


/*
  BREADTH-FIRST SEARCH
     -> Level Order Traversal
*/

function levelOrder(root, queue = [], result = []) {
    if (!root) return

    queue.push(root)
    while(queue.length) {
        const currentNode = queue.shift();
        result.push(currentNode.data)
        if(currentNode.left) queue.push(currentNode.left)
        if(currentNode.right) queue.push(currentNode.right)
    }

    return result;
}


/* Creating the root node 
   with example tree for testing

	    M
           / \
	  B   Q
         / \   \
	A   C   Z
*/

const root = new Node('M');

// Insert nodes into the BST using the insert method
root.insert('B');
root.insert('Q');
root.insert('Z');
root.insert('A');
root.insert('C');

// BREADTH-FIRST TRAVERSAL
levelOrder(root))  // [ 'M', 'B', 'Q', 'A', 'C', 'Z' ]

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

struct queue {
int data;
struct queue* next;

};
struct queue* front = NULL;
struct queue* rear = NULL;
void push(struct queuenode) {
struct queue temp = (struct queue*)malloc(sizeof(struct queue));
temp->data = node->data;
temp->next = NULL;
if (rear == NULL && front == NULL) {
front = rear = temp;
return;
}rear->next = temp;
rear = temp;
}
void pop() {
struct queue* temp = front;
if (rear == NULL && front == NULL) {
return;
}if (front == rear) {
front = rear = NULL;
}
front = front->next;
free(temp);
}
struct BstNode {
int data;
struct BstNode* left;
struct BstNode* right;
};

struct BstNode* Getnewnode(int data) {
struct BstNode* newnode = (struct BstNode*)malloc(sizeof(struct BstNode));
newnode->data = data;
newnode->left = NULL;
newnode->right = NULL;
return newnode;
}
struct BstNode* Insert(struct BstNode* root, int data) {
if (root == NULL) {
root = Getnewnode(data);
}
else if (data <= root->data) {
root->left = Insert(root->left, data);
}
else {
root->right = Insert(root->right, data);
}return root;
}

struct queue*get() {

 return  front; 

}
void Levelorder(struct BstNoderoot ) {
if (root == NULL) {
return;
}push(root);
while (front != NULL && rear != NULL) {
struct BstNode current =get() ;

	printf("%d ", current->data);if (current->left != NULL)push(current->left);
	if (current->right!= NULL)push(current->right);
	pop();
}

}
int main() {
struct BstNode* root = NULL;
root = Insert(root, 3);
root = Insert(root, 6);
root = Insert(root, 1);
root = Insert(root, 9);
root = Insert(root, 11);
root = Insert(root, 8);
root = Insert(root, 10);
root = Insert(root, 19);
root = Insert(root, 5);
Levelorder(root);
return 0;
}### 求助只能打印出来第一个root

老师讲的雀氏好，通俗易懂