Level order traversal in spiral form | Using Deque
Given a Binary Tree, the task is to print spiral order traversal of the given tree. For below tree, the function should print 1, 2, 3, 4, 5, 6, 7.
Examples:
Input:
1
/ \
3 2
Output :
1
3 2
Input :
10
/ \
20 30
/ \
40 60
Output :
10
20 30
60 40
We have seen recursive and iterative solutions using two stacks and an approach using one stack and one queue. In this post, a solution with one deque is discussed. The idea is to use a direction variable and decide whether to pop elements from the front or from the rear based on the value of this direction variable.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
class Node {
public :
int data;
Node *left, *right;
Node( int val)
{
data = val;
left = NULL;
right = NULL;
}
};
void spiralOrder(Node* root)
{
deque<Node*> d;
d.push_back(root);
int dir = 0;
while (!d.empty()) {
int size = d.size();
while (size--) {
if (dir == 0) {
Node* temp = d.back();
d.pop_back();
if (temp->right)
d.push_front(temp->right);
if (temp->left)
d.push_front(temp->left);
cout << temp->data << " " ;
}
else {
Node* temp = d.front();
d.pop_front();
if (temp->left)
d.push_back(temp->left);
if (temp->right)
d.push_back(temp->right);
cout << temp->data << " " ;
}
}
cout << endl;
dir = 1 - dir;
}
}
int main()
{
Node* root = new Node(10);
root->left = new Node(20);
root->right = new Node(30);
root->left->left = new Node(40);
root->left->right = new Node(60);
spiralOrder(root);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static class Node
{
int data;
Node left, right;
Node( int val)
{
data = val;
left = null ;
right = null ;
}
};
static void spiralOrder(Node root)
{
Deque<Node> d = new LinkedList<Node>();
d.addLast(root);
int dir = 0 ;
while (d.size() > 0 )
{
int size = d.size();
while (size--> 0 )
{
if (dir == 0 )
{
Node temp = d.peekLast();
d.pollLast();
if (temp.right != null )
d.addFirst(temp.right);
if (temp.left != null )
d.addFirst(temp.left);
System.out.print(temp.data + " " );
}
else
{
Node temp = d.peekFirst();
d.pollFirst();
if (temp.left != null )
d.addLast(temp.left);
if (temp.right != null )
d.addLast(temp.right);
System.out.print(temp.data + " " );
}
}
System.out.println();
dir = 1 - dir;
}
}
public static void main(String args[])
{
Node root = new Node( 10 );
root.left = new Node( 20 );
root.right = new Node( 30 );
root.left.left = new Node( 40 );
root.left.right = new Node( 60 );
spiralOrder(root);
}
}
|
Python3
class Node :
def __init__( self ,val) :
self .data = val;
self .left = None ;
self .right = None ;
def spiralOrder(root) :
d = [];
d.append(root);
direct = 0 ;
while ( len (d) ! = 0 ) :
size = len (d);
while (size) :
size - = 1 ;
if (direct = = 0 ) :
temp = d.pop();
if (temp.right) :
d.insert( 0 , temp.right);
if (temp.left) :
d.insert( 0 , temp.left);
print (temp.data, end = " " );
else :
temp = d[ 0 ];
d.pop( 0 );
if (temp.left) :
d.append(temp.left);
if (temp.right) :
d.append(temp.right);
print (temp.data ,end = " " );
print ()
direct = 1 - direct;
if __name__ = = "__main__" :
root = Node( 10 );
root.left = Node( 20 );
root.right = Node( 30 );
root.left.left = Node( 40 );
root.left.right = Node( 60 );
spiralOrder(root);
|
C#
using System;
using System.Collections.Generic;
class GFG
{
class Node
{
public int data;
public Node left, right;
public Node( int val)
{
data = val;
left = null ;
right = null ;
}
}
static void SpiralOrder(Node root)
{
Queue<Node> d = new Queue<Node>();
d.Enqueue(root);
int dir = 0;
while (d.Count > 0)
{
int size = d.Count;
while (size-- > 0)
{
if (dir == 1)
{
Node temp = d.Peek();
d.Dequeue();
if (temp.right != null )
d.Enqueue(temp.right);
if (temp.left != null )
d.Enqueue(temp.left);
Console.Write(temp.data + " " );
}
else
{
Node temp = d.Peek();
d.Dequeue();
if (temp.left != null )
d.Enqueue(temp.left);
if (temp.right != null )
d.Enqueue(temp.right);
Console.Write(temp.data + " " );
}
}
Console.WriteLine();
dir = 1 - dir;
}
}
static void Main( string [] args)
{
Node root = new Node(10);
root.left = new Node(20);
root.right = new Node(30);
root.left.left = new Node(40);
root.left.right = new Node(60);
SpiralOrder(root);
}
}
|
Javascript
<script>
class Node {
constructor(val)
{
this .data = val;
this .left = null ;
this .right = null ;
}
};
function spiralOrder(root)
{
var d = [];
d.push(root);
var dir = 0;
while (d.length!=0) {
var size = d.length;
while (size-- >0) {
if (dir == 0) {
var temp = d[d.length-1];
d.pop();
if (temp.right!= null )
d.unshift(temp.right);
if (temp.left!= null )
d.unshift(temp.left);
document.write( temp.data + " " );
}
else {
var temp = d[0];
d.shift();
if (temp.left != null )
d.push(temp.left);
if (temp.right!= null )
d.push(temp.right);
document.write( temp.data + " " );
}
}
document.write( "<br>" );
dir = 1 - dir;
}
}
var root = new Node(10);
root.left = new Node(20);
root.right = new Node(30);
root.left.left = new Node(40);
root.left.right = new Node(60);
spiralOrder(root);
</script>
|
Time Complexity: O(N)
Space Complexity: O(N)
where N is the number of Nodes
Last Updated :
11 Jan, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...