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);
}

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

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