# Zig Zag Level order traversal of a tree using single array

Write a function to print spiral order traversal of a tree. For below tree, function should print 1, 2, 3, 4, 5, 6, 7.

We have discussed naive approach and two stack based approach in Level Order with recursion and multiple stacks
The idea behind this approach is first we have to take a queue, a direction flag and a separation flag which is NULL

1. Insert the root element into the queue and again insert NULL into the queue.
2. For every element in the queue insert its child nodes.
3. If a NULL is encountered then check the direction to traverse the particular level is left to right or right to left. If it’s an even level then traverse from left to right otherwise traverse the tree in right to level order i.e., from the front to the previous front i.e., from the current NULL to to the last NULL that has been visited. This continues till the last level then there the loop breaks and we print what is left (that has not printed) by checking the direction to print.

Following is the implementation of the explanation

 `// C++ program to print level order traversal` `// in spiral form using a single dequeue` `#include `   `struct` `Node {` `    ``int` `data;` `    ``struct` `Node *left, *right;` `};`   `// A utility function to create a new node` `struct` `Node* newNode(``int` `data)` `{` `    ``struct` `Node* node = ``new` `struct` `Node;` `    ``node->data = data;` `    ``node->left = node->right = NULL;` `    ``return` `(node);` `}`   `// function to print the level order traversal` `void` `levelOrder(``struct` `Node* root, ``int` `n)` `{` `    ``// We can just take the size as H+N which` `    ``// implies the height of the tree with the ` `    ``// size of the tree` `    ``struct` `Node* queue[2 * n];` `    ``int` `top = -1;` `    ``int` `front = 1;` `    ``queue[++top] = NULL;` `    ``queue[++top] = root;` `    ``queue[++top] = NULL;`   `    ``// struct Node* t=root;` `    ``int` `prevFront = 0, count = 1;` `    ``while` `(1) {`   `        ``struct` `Node* curr = queue[front];`   `        ``// A level separator found` `        ``if` `(curr == NULL) {`   `            ``// If this is the only item in dequeue` `            ``if` `(front == top)` `                ``break``;`   `            ``// Else print contents of previous level` `            ``// according to count` `            ``else` `{` `                ``if` `(count % 2 == 0) {` `                    ``for` `(``int` `i = prevFront + 1; i < front; i++)` `                        ``printf``(``"%d "``, queue[i]->data);` `                ``}` `                ``else` `{` `                    ``for` `(``int` `i = front - 1; i > prevFront; i--)` `                        ``printf``(``"%d "``, queue[i]->data);` `                ``}`   `                ``prevFront = front;` `                ``count++;` `                ``front++;`   `                ``// Insert a new level separator` `                ``queue[++top] = NULL;`   `                ``continue``;` `            ``}` `        ``}`   `        ``if` `(curr->left != NULL)` `            ``queue[++top] = curr->left;` `        ``if` `(curr->right != NULL)` `            ``queue[++top] = curr->right;` `        ``front++;` `    ``}`   `    ``if` `(count % 2 == 0) {` `        ``for` `(``int` `i = prevFront + 1; i < top; i++)` `            ``printf``(``"%d "``, queue[i]->data);` `    ``}` `    ``else` `{` `        ``for` `(``int` `i = top - 1; i > prevFront; i--)` `            ``printf``(``"%d "``, queue[i]->data);` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``struct` `Node* root = newNode(1);` `    ``root->left = newNode(2);` `    ``root->right = newNode(3);` `    ``root->left->left = newNode(7);` `    ``root->left->right = newNode(6);` `    ``root->right->left = newNode(5);` `    ``root->right->right = newNode(4);` `    ``levelOrder(root, 7);`   `    ``return` `0;` `}`

 `// Java program to print level order traversal` `// in spiral form using a single dequeue` `class` `Solution` `{` `    `  `static` `class` `Node ` `{` `    ``int` `data;` `    ``Node left, right;` `};`   `// A utility function to create a new node` `static` `Node newNode(``int` `data)` `{` `    ``Node node = ``new` `Node();` `    ``node.data = data;` `    ``node.left = node.right = ``null``;` `    ``return` `(node);` `}`   `// function to print the level order traversal` `static` `void` `levelOrder( Node root, ``int` `n)` `{` `    ``// We can just take the size as H+N which` `    ``// implies the height of the tree with the ` `    ``// size of the tree` `    ``Node queue[] = ``new` `Node[``2` `* n];` `    `  `    ``for``(``int` `i = ``0``; i < ``2` `* n; i++)` `        ``queue[i] = ``new` `Node();` `    `  `    ``int` `top = -``1``;` `    ``int` `front = ``1``;` `    ``queue[++top] = ``null``;` `    ``queue[++top] = root;` `    ``queue[++top] = ``null``;`   `    ``// Node t=root;` `    ``int` `prevFront = ``0``, count = ``1``;` `    ``while` `(``true``)` `    ``{`   `        ``Node curr = queue[front];`   `        ``// A level separator found` `        ``if` `(curr == ``null``) ` `        ``{`   `            ``// If this is the only item in dequeue` `            ``if` `(front == top)` `                ``break``;`   `            ``// Else print contents of previous level` `            ``// according to count` `            ``else` `            ``{` `                ``if` `(count % ``2` `== ``0``)` `                ``{` `                    ``for` `(``int` `i = prevFront + ``1``; i < front; i++)` `                        ``System.out.printf(``"%d "``, queue[i].data);` `                ``}` `                ``else` `                ``{` `                    ``for` `(``int` `i = front - ``1``; i > prevFront; i--)` `                        ``System.out.printf(``"%d "``, queue[i].data);` `                ``}`   `                ``prevFront = front;` `                ``count++;` `                ``front++;`   `                ``// Insert a new level separator` `                ``queue[++top] = ``null``;`   `                ``continue``;` `            ``}` `        ``}`   `        ``if` `(curr.left != ``null``)` `            ``queue[++top] = curr.left;` `        ``if` `(curr.right != ``null``)` `            ``queue[++top] = curr.right;` `        ``front++;` `    ``}`   `    ``if` `(count % ``2` `== ``0``) ` `    ``{` `        ``for` `(``int` `i = prevFront + ``1``; i < top; i++)` `            ``System.out.printf(``"%d "``, queue[i].data);` `    ``}` `    ``else` `    ``{` `        ``for` `(``int` `i = top - ``1``; i > prevFront; i--)` `            ``System.out.printf(``"%d "``, queue[i].data);` `    ``}` `}`   `// Driver code` `public` `static` `void` `main(String args[])` `{` `    ``Node root = newNode(``1``);` `    ``root.left = newNode(``2``);` `    ``root.right = newNode(``3``);` `    ``root.left.left = newNode(``7``);` `    ``root.left.right = newNode(``6``);` `    ``root.right.left = newNode(``5``);` `    ``root.right.right = newNode(``4``);` `    ``levelOrder(root, ``7``);` `}` `}`   `// This code is contributed by Arnab Kundu`

 `// C# program to print level order traversal` `// in spiral form using a single dequeue` `using` `System;` `class` `GFG` `{   ` `public` `class` `Node ` `{` `    ``public` `int` `data;` `    ``public` `Node left, right;` `};`   `// A utility function to create a new node` `static` `Node newNode(``int` `data)` `{` `    ``Node node = ``new` `Node();` `    ``node.data = data;` `    ``node.left = node.right = ``null``;` `    ``return` `(node);` `}`   `// function to print the level order traversal` `static` `void` `levelOrder( Node root, ``int` `n)` `{` `    ``// We can just take the size as H+N which` `    ``// implies the height of the tree with the ` `    ``// size of the tree` `    ``Node []queue = ``new` `Node[2 * n];` `    `  `    ``for``(``int` `i = 0; i < 2 * n; i++)` `        ``queue[i] = ``new` `Node();` `    `  `    ``int` `top = -1;` `    ``int` `front = 1;` `    ``queue[++top] = ``null``;` `    ``queue[++top] = root;` `    ``queue[++top] = ``null``;`   `    ``// Node t=root;` `    ``int` `prevFront = 0, count = 1;` `    ``while` `(``true``)` `    ``{`   `        ``Node curr = queue[front];`   `        ``// A level separator found` `        ``if` `(curr == ``null``) ` `        ``{`   `            ``// If this is the only item in dequeue` `            ``if` `(front == top)` `                ``break``;`   `            ``// Else print contents of previous level` `            ``// according to count` `            ``else` `            ``{` `                ``if` `(count % 2 == 0)` `                ``{` `                    ``for` `(``int` `i = prevFront + 1; ` `                             ``i < front; i++)` `                        ``Console.Write(``" "` `+ queue[i].data);` `                ``}` `                ``else` `                ``{` `                    ``for` `(``int` `i = front - 1; ` `                             ``i > prevFront; i--)` `                        ``Console.Write(``" "` `+ queue[i].data);` `                ``}`   `                ``prevFront = front;` `                ``count++;` `                ``front++;`   `                ``// Insert a new level separator` `                ``queue[++top] = ``null``;`   `                ``continue``;` `            ``}` `        ``}`   `        ``if` `(curr.left != ``null``)` `            ``queue[++top] = curr.left;` `        ``if` `(curr.right != ``null``)` `            ``queue[++top] = curr.right;` `        ``front++;` `    ``}`   `    ``if` `(count % 2 == 0) ` `    ``{` `        ``for` `(``int` `i = prevFront + 1; i < top; i++)` `            ``Console.Write(``" "` `+ queue[i].data);` `    ``}` `    ``else` `    ``{` `        ``for` `(``int` `i = top - 1; i > prevFront; i--)` `            ``Console.Write(``" "` `+ queue[i].data);` `    ``}` `}`   `// Driver code` `public` `static` `void` `Main(String []args)` `{` `    ``Node root = newNode(1);` `    ``root.left = newNode(2);` `    ``root.right = newNode(3);` `    ``root.left.left = newNode(7);` `    ``root.left.right = newNode(6);` `    ``root.right.left = newNode(5);` `    ``root.right.right = newNode(4);` `    ``levelOrder(root, 7);` `}` `}`   `// This code is contributed by gauravrajput1`

Output:
```1 2 3 4 5 6 7

```

Time Complexity: O(n)
Auxiliary Space : O(2*n) = O(n)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :