# Level order traversal in spiral form | Using one stack and one queue

Write a function to print spiral order traversal of a tree. For below tree, function should print 1, 2, 3, 4, 5, 6, 7. You are allowed to use only one stack.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

We have seen recursive and iterative solutions using two stacks . In this post, a solution with one stack and one queue is discussed. The idea is to keep on entering nodes like normal level order traversal, but during printing, in alternative turns push them onto the stack and print them, and in other traversals, just print them the way they are present in the queue.

Following is the implementation of the idea.

## C++

 `// CPP program to print level order traversal ` `// in spiral form using one queue and one stack. ` `#include ` `using` `namespace` `std; ` ` `  `struct` `Node { ` `   ``int` `data; ` `   ``Node *left, *right; ` `}; ` ` `  `/* Utility function to create a new tree node */` `Node* newNode(``int` `val) ` `{ ` `    ``Node* new_node = ``new` `Node; ` `    ``new_node->data = val; ` `    ``new_node->left = new_node->right = NULL; ` `    ``return` `new_node; ` `} ` ` `  `/* Function to print a tree in spiral form  ` `   ``using one stack */` `void` `printSpiralUsingOneStack(Node* root) ` `{ ` `    ``if` `(root == NULL) ` `        ``return``; ` ` `  `    ``stack<``int``> s;  ` `    ``queue q; ` ` `  `    ``bool` `reverse = ``true``; ` `    ``q.push(root); ` `    ``while` `(!q.empty()) { ` ` `  `        ``int` `size = q.size(); ` `        ``while` `(size) { ` `            ``Node* p = q.front(); ` `            ``q.pop(); ` ` `  `            ``// if reverse is true, push node's  ` `            ``// data onto the stack, else print it ` `            ``if` `(reverse) ` `                ``s.push(p->data); ` `            ``else` `                ``cout << p->data << ``" "``; ` ` `  `            ``if` `(p->left) ` `                ``q.push(p->left); ` `            ``if` `(p->right) ` `                ``q.push(p->right); ` `            ``size--; ` `        ``} ` ` `  `        ``// print nodes from the stack if  ` `        ``// reverse is true ` `        ``if` `(reverse) { ` `            ``while` `(!s.empty()) { ` `                ``cout << s.top() << ``" "``; ` `                ``s.pop(); ` `            ``} ` `        ``} ` ` `  `        ``// the next row has to be printed as  ` `        ``// it is, hence change the value of  ` `        ``// reverse ` `        ``reverse = !reverse; ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``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); ` `    ``printSpiralUsingOneStack(root); ` `    ``return` `0; ` `} `

## Java

 `// Java program to print level order traversal ` `// in spiral form using one queue and one stack. ` `import` `java.util.*; ` `class` `GFG  ` `{  ` `static` `class` `Node  ` `{ ` `    ``int` `data; ` `    ``Node left, right; ` `}; ` ` `  `/* Utility function to create a new tree node */` `static` `Node newNode(``int` `val) ` `{ ` `    ``Node new_node = ``new` `Node(); ` `    ``new_node.data = val; ` `    ``new_node.left = new_node.right = ``null``; ` `    ``return` `new_node; ` `} ` ` `  `/* Function to print a tree in spiral form  ` `using one stack */` `static` `void` `printSpiralUsingOneStack(Node root) ` `{ ` `    ``if` `(root == ``null``) ` `        ``return``; ` ` `  `    ``Stack s = ``new` `Stack();  ` `    ``Queue q = ``new` `LinkedList(); ` ` `  `    ``boolean` `reverse = ``true``; ` `    ``q.add(root); ` `    ``while` `(!q.isEmpty())  ` `    ``{ ` `        ``int` `size = q.size(); ` `        ``while` `(size > ``0``)  ` `        ``{ ` `            ``Node p = q.peek(); ` `            ``q.remove(); ` ` `  `            ``// if reverse is true, push node's  ` `            ``// data onto the stack, else print it ` `            ``if` `(reverse) ` `                ``s.add(p.data); ` `            ``else` `                ``System.out.print(p.data + ``" "``); ` ` `  `            ``if` `(p.left != ``null``) ` `                ``q.add(p.left); ` `            ``if` `(p.right != ``null``) ` `                ``q.add(p.right); ` `            ``size--; ` `        ``} ` ` `  `        ``// print nodes from the stack if  ` `        ``// reverse is true ` `        ``if` `(reverse)  ` `        ``{ ` `            ``while` `(!s.empty())  ` `            ``{ ` `                ``System.out.print(s.peek() + ``" "``); ` `                ``s.pop(); ` `            ``} ` `        ``} ` ` `  `        ``// the next row has to be printed as  ` `        ``// it is, hence change the value of  ` `        ``// reverse ` `        ``reverse = !reverse; ` `    ``} ` `} ` ` `  `// 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``); ` `    ``printSpiralUsingOneStack(root); ` `} ` `} ` ` `  `// This code is contributed by Princi Singh `

## Python

 `# Python program to print level order traversal ` `# in spiral form using one queue and one stack. ` ` `  `# Utility class to create a new node  ` `class` `Node:  ` `    ``def` `__init__(``self``, key):  ` `        ``self``.key ``=` `key  ` `        ``self``.left ``=` `self``.right ``=` `None` ` `  `# Utility function to create a new tree node  ` `def` `newNode(val): ` ` `  `    ``new_node ``=` `Node(``0``) ` `    ``new_node.data ``=` `val ` `    ``new_node.left ``=` `new_node.right ``=` `None` `    ``return` `new_node ` ` `  `# Function to print a tree in spiral form  ` `# using one stack  ` `def` `printSpiralUsingOneStack(root): ` ` `  `    ``if` `(root ``=``=` `None``): ` `        ``return` ` `  `    ``s ``=` `[]  ` `    ``q ``=` `[] ` ` `  `    ``reverse ``=` `True` `    ``q.append(root) ` `    ``while` `(``len``(q) > ``0``) : ` ` `  `        ``size ``=` `len``(q) ` `        ``while` `(size > ``0``) : ` `            ``p ``=` `q[``0``] ` `            ``q.pop(``0``) ` ` `  `            ``# if reverse is true, push node's  ` `            ``# data onto the stack, else print it ` `            ``if` `(reverse): ` `                ``s.append(p.data) ` `            ``else``: ` `                ``print``( p.data ,end ``=` `" "``) ` ` `  `            ``if` `(p.left !``=` `None``): ` `                ``q.append(p.left) ` `            ``if` `(p.right !``=` `None``): ` `                ``q.append(p.right) ` `            ``size ``=` `size ``-` `1` `         `  `        ``# print nodes from the stack if  ` `        ``# reverse is true ` `        ``if` `(reverse) : ` `            ``while` `(``len``(s)) : ` `                ``print``( s[``-``1``],end``=` `" "``) ` `                ``s.pop() ` `             `  `        ``# the next row has to be printed as  ` `        ``# it is, hence change the value of  ` `        ``# reverse ` `        ``reverse ``=` `not` `reverse ` `     `  `# Driver Code ` `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``) ` `printSpiralUsingOneStack(root) ` ` `  `# This code is contributed by Arnab Kundu `

## C#

 `// C# program to print level order traversal ` `// in spiral form using one queue and one stack. ` `using` `System; ` `using` `System.Collections.Generic;  ` ` `  `class` `GFG  ` `{  ` `public` `class` `Node  ` `{ ` `    ``public` `int` `data; ` `    ``public` `Node left, right; ` `}; ` ` `  `/* Utility function to create a new tree node */` `static` `Node newNode(``int` `val) ` `{ ` `    ``Node new_node = ``new` `Node(); ` `    ``new_node.data = val; ` `    ``new_node.left = new_node.right = ``null``; ` `    ``return` `new_node; ` `} ` ` `  `/* Function to print a tree in spiral form  ` `using one stack */` `static` `void` `printSpiralUsingOneStack(Node root) ` `{ ` `    ``if` `(root == ``null``) ` `        ``return``; ` ` `  `    ``Stack<``int``> s = ``new` `Stack<``int``>();  ` `    ``Queue q = ``new` `Queue(); ` ` `  `    ``Boolean reverse = ``true``; ` `    ``q.Enqueue(root); ` `    ``while` `(q.Count != 0)  ` `    ``{ ` `        ``int` `size = q.Count; ` `        ``while` `(size > 0)  ` `        ``{ ` `            ``Node p = q.Peek(); ` `            ``q.Dequeue(); ` ` `  `            ``// if reverse is true, push node's  ` `            ``// data onto the stack, else print it ` `            ``if` `(reverse) ` `                ``s.Push(p.data); ` `            ``else` `                ``Console.Write(p.data + ``" "``); ` ` `  `            ``if` `(p.left != ``null``) ` `                ``q.Enqueue(p.left); ` `            ``if` `(p.right != ``null``) ` `                ``q.Enqueue(p.right); ` `            ``size--; ` `        ``} ` ` `  `        ``// print nodes from the stack if  ` `        ``// reverse is true ` `        ``if` `(reverse)  ` `        ``{ ` `            ``while` `(s.Count != 0)  ` `            ``{ ` `                ``Console.Write(s.Peek() + ``" "``); ` `                ``s.Pop(); ` `            ``} ` `        ``} ` ` `  `        ``// the next row has to be printed as  ` `        ``// it is, hence change the value of  ` `        ``// reverse ` `        ``reverse = !reverse; ` `    ``} ` `} ` ` `  `// 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); ` `    ``printSpiralUsingOneStack(root); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Jiv `

Output:

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

Time Complexity :
O(n)
Auxiliary Space : O(n)

My Personal Notes arrow_drop_up 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 :

4

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.