Binary Tree Prob

[Deshna]

Given a Binary Tree (not necessarily complete), you have to print the nodes of the tree such that, each line contains values of nodes at a particular level or in other words you have to print the nodes level-by-level.

[ARUN GUPTA]

Nodes may be Stored in any fashion ?

[Deshna]

Yes they can be ... its a simple Binary Tree.

[ARUN GUPTA]

please run this code this is in java and for every entry of node value ... you have to enter the y please run this code 

import java.util.*;

import java.util.Random ;

import java.util.LinkedList;

import java.util.Queue;

public class BinarTree_Leve_by_lavel_traversal

{

       public  static Queue queue = new LinkedList();

public static void main (String [] args)

{

new BinarTree_Leve_by_lavel_traversal().run();

}

public void run()

{ char in = 'y' ;

Scanner sc = new Scanner(System.in);

System.out.println("Enter the Root node Value :");

int val = 0;

val = sc.nextInt();

Node rootnode = new Node(val);

System.out.println("Building the Tree with Root Value : " +rootnode.value );

while(in == 'y'){

System.out.println("Do you Want To enter a new Node (Reply with only y/n) :");

in = 'n';

String line = sc.next();

in = line.charAt(0);

if(in != 'y') {

System.out.println("Thanx to use this code " );

//exit 0;

}

else {

System.out.println("Enter the New node Value :");

val = 0;

val = sc.nextInt();

insert(rootnode, val);

}

}

queue.offer(rootnode.value);

leveltraver(rootnode);

System.out.println("Do you Want To Traverse (Reply with only y/n) :");

char tra = 'n';

String t = sc.next();

tra = t.charAt(0);

if(tra == 'y') {

System.out.println("\n\n\nTraversing tree in inorder");

  System.out.println("=================================");

inorder(rootnode);

System.out.println("\n\n\nTraversing tree in postorder");

  System.out.println("=================================");

postorder(rootnode);

System.out.println("\n\n\nTraversing tree in priorder");

  System.out.println("=================================");

preorder(rootnode);

System.out.println("\n\n\nTraversing tree in ZigZag");

  System.out.println("=================================");

Random rg = new Random();

int z = rg.nextInt(2);

zig(rootnode , z);

}

}//end of run method

public  void  insert(Node node , int value)

{

//BinarTree_Leve_by_lavel_traversal = new BinarTree_Leve_by_lavel_traversal();

if(value < node.value)

{

if(node.left != null) {

insert (node.left ,value );

}

else {

node.left = new Node(value);

System.out.println("Node Inserted with value "+value+"to left of node " + node.value);

}

}

else if (value > node.value) {

if(node.right != null) {

insert (node.right ,value );

}

else {

node.right = new Node(value);

System.out.println("Node Inserted with value "+value+"to right of node " + node.value);

}

}

}

public void inorder(Node node) {

if(node != null) {

// System.out.println("Trace : node " ,+node.value);

inorder(node.left);

//System.out.println("Trace : node " ,+node.value);

System.out.println("  Traversed " + node.value);

inorder(node.right);

}

}

public void postorder(Node node) {

//System.out.println("Trace : node " ,+node.val);

if(node != null) {

postorder(node.left);

postorder(node.right);

System.out.println("  Traversed " + node.value);

}

}

public void preorder(Node node) {

//System.out.println("Trace : node " ,+node.val);

if(node != null) {

System.out.println("  Traversed " + node.value);

preorder(node.left);

preorder(node.right);

}

}

public void zig(Node node , int p) {

//System.out.println("Trace : node " ,+node.val);

if(node == null) {

System.exit(0);

} System.out.println("  Traversed " + node.value);

System.out.println(" Towards" + p);

if(p == 0)

{

p = 1;

zig(node.left , p);

System.out.println(" To" + p);

}

else {

p = 0;

zig(node.right , p);

}

}

/*public void leveltraver(Node node)

{

//static int level = 0; 

if(node == null)

{

int a = 0;

}

else

{

queue.poll();

System.out.print(+node.value+ ":");

if(node.left != null)

{

queue.offer(node.left.value);}

if(node.right != null)

{

queue.offer(node.right.value);

}

leveltraver(node.left);

leveltraver(node.right);

}

}*/

public void leveltraver(Node node)

{

//static int level = 0; 

if(node == null)

{

int a = 0;

}

else

{

System.out.print(":"+queue.poll());

if(node.left != null)

{

queue.offer(node.left.value);}

if(node.right != null)

{

queue.offer(node.right.value);

}

leveltraver(node.left);

leveltraver(node.right);

}

}

}

Enter code here...

[Deshna]

Pass on the value of root pointer of the tree ...

void printLevel(struct node* root){

    int size = 0;

    if (root == NULL) return;

    queue <struct node*> myqueue;

    myqueue.push(root);

    size++;

    while (!myqueue.empty()) {

        printf("%d\t",myqueue.front()->key);

        if (myqueue.front()->left != NULL) {

            myqueue.push(myqueue.front()->left);

        }

        if (myqueue.front()->right != NULL) {

            myqueue.push(myqueue.front()->right);

        }

        myqueue.pop();

        size--;

        if (size == 0) {

            printf("\n");

            size = myqueue.size();

        }

    }

}