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

Saw your youtube lesson. Thank you. Better than my instructor.

how about binary tree traversal its not binary tree but binary search tree.left side of root node is lesser also right side is higher.

### CODE IN C

#include <stdio.h>
#include <stdlib.h>
#define n 100

struct BstNode* queue[n];
int front=-1,rear=-1;

void Enqueue();
void Dequeue();
struct BstNode* first();
int isEmpty();
struct BstNode* insert();
struct BstNode* NewNode();
void LevelOrder();

/* run this program using the console pauser or add your own getch, system("pause") or input loop */
struct BstNode{
	int data;
	struct BstNode* right;
	struct BstNode* left;
};

void Enqueue(struct BstNode* x){
	if(front==-1&&rear==-1){
		front=rear=0;
	}else if((rear+1)%n==front){
		printf("Memory Full\n");exit(1);
	}else{
		rear = (rear+1)%n;
	}
	queue[rear] = x;
}
void Dequeue(){
	if(front==-1&&rear==-1)return;
	if(front==0&&rear==0){
		front=rear=-1;
	}else{
		front = (front+1)%n;
	}
}
struct BstNode* first(){
	return queue[front];
}
int isEmpty(){
	if(front==-1&&rear==-1) return 1;
	return 0;
}

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;
}
struct BstNode* insert(struct BstNode* root,int data){
	if(root==NULL){
		root = NewNode(data);
	}else if(data<=root->data){
		root->left = insert(root->left,data);
	}else if(data>root->data){
		root->right = insert(root->right,data);
	}
	return root;
	
}
struct BstNode* NewNode(int data){
	struct BstNode* temp = (struct BstNode*)malloc(sizeof(struct BstNode));
	temp->data = data;
	temp->left = temp->right = NULL;
	return temp;
}
void LevelOrder(struct BstNode* root){
	if(root==NULL) return;
	Enqueue(root);
	while(!isEmpty()){
		struct BstNode* current = first();
		printf("%d ",current->data);
		if(current->left!=NULL) Enqueue(current->left);
		if(current->right!=NULL) Enqueue(current->right);
		Dequeue();
	}
}

Best Data Structure implementation so far

how to manage this code for user inputs

I just want to say thanks to you for sharing the resources.

Started learning DS since last 25 days back, not sure about other programming language. I can modify DS in C/C++ program after learning it from the YouTube channel and the challenge it gives to write some codes of your own after declaring some functions how much it is required others we need to write. Thank you MyCodeSchool for helping me out to learn new techniques in DS.

                      F
		  /   \
		D      J
	       / \    / \
	     B   E   G   K
	    / \ / \ / \    \
	   A  CS LN I   T
	                 /
	                H		

Hello All Can Anybody. Help me out with this Binary Tree-Level Order Traversal.?
I tried and reached till this much only:-
int main()
{
Node* root = NULL;
root = Insert(root,'F'); root = Insert(root,'D');
root = Insert(root,'J'); root = Insert(root,'K');
root = Insert(root,'B'); root = Insert(root,'E');
root = Insert(root,'G'); root = Insert(root,'S');
root = Insert(root,'A'); root = Insert(root,'C');
root = Insert(root,'L'); root = Insert(root,'N');
LevelOrder(root);
}
I get output as: - F D J B E G K A C S L N

Output I want as: - F D J B E G K A C S L N I T H

next whatever i am trying its going wrong. please help me out here.

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

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