Given a binary tree, the task is to print the nodes of the tree in an anti-clockwise spiral manner.
Examples:
Input: 1 / \ 2 3 / \ / \ 4 5 6 7 Output: 1 4 5 6 7 3 2 Input: 1 / \ 2 3 / / \ 4 5 6 / \ / / \ 7 8 9 10 11 Output: 1 7 8 9 10 11 3 2 4 5 6
Approach: The idea is to use two variables i initialized to 1 and j initialized to the height of tree and run a while loop which wont break until i becomes greater than j. We will use another variable flag and initialize it to 0. Now in the while loop we will check a condition that if flag is equal to 0 we will traverse the tree from right to left and mark flag as 1 so that next time we traverse the tree from left to right and then increment the value of i so that next time we visit the level just below the current level. Also when we will traverse the level from bottom we will mark flag as 0 so that next time we traverse the tree from left to right and then decrement the value of j so that next time we visit the level just above the current level. Repeat the whole process until the binary tree is completely traversed.
Below is the implementation of the above approach:
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// Binary tree node struct Node {
struct Node* left;
struct Node* right;
int data;
Node( int data)
{
this ->data = data;
this ->left = NULL;
this ->right = NULL;
}
}; // Recursive Function to find height // of binary tree int height( struct Node* root)
{ // Base condition
if (root == NULL)
return 0;
// Compute the height of each subtree
int lheight = height(root->left);
int rheight = height(root->right);
// Return the maximum of two
return max(1 + lheight, 1 + rheight);
} // Function to Print Nodes from left to right void leftToRight( struct Node* root, int level)
{ if (root == NULL)
return ;
if (level == 1)
cout << root->data << " " ;
else if (level > 1) {
leftToRight(root->left, level - 1);
leftToRight(root->right, level - 1);
}
} // Function to Print Nodes from right to left void rightToLeft( struct Node* root, int level)
{ if (root == NULL)
return ;
if (level == 1)
cout << root->data << " " ;
else if (level > 1) {
rightToLeft(root->right, level - 1);
rightToLeft(root->left, level - 1);
}
} // Function to print anti clockwise spiral // traversal of a binary tree void antiClockWiseSpiral( struct Node* root)
{ int i = 1;
int j = height(root);
// Flag to mark a change in the direction
// of printing nodes
int flag = 0;
while (i <= j) {
// If flag is zero print nodes
// from right to left
if (flag == 0) {
rightToLeft(root, i);
// Set the value of flag as zero
// so that nodes are next time
// printed from left to right
flag = 1;
// Increment i
i++;
}
// If flag is one print nodes
// from left to right
else {
leftToRight(root, j);
// Set the value of flag as zero
// so that nodes are next time
// printed from right to left
flag = 0;
// Decrement j
j--;
}
}
} // Driver code int main()
{ struct Node* root = new Node(1);
root->left = new Node(2);
root->right = new Node(3);
root->left->left = new Node(4);
root->right->left = new Node(5);
root->right->right = new Node(7);
root->left->left->left = new Node(10);
root->left->left->right = new Node(11);
root->right->right->left = new Node(8);
antiClockWiseSpiral(root);
return 0;
} |
// Java implementation of the approach class GfG
{ // Binary tree node static class Node
{ Node left;
Node right;
int data;
Node( int data)
{
this .data = data;
this .left = null ;
this .right = null ;
}
} // Recursive Function to find height // of binary tree static int height(Node root)
{ // Base condition
if (root == null )
return 0 ;
// Compute the height of each subtree
int lheight = height(root.left);
int rheight = height(root.right);
// Return the maximum of two
return Math.max( 1 + lheight, 1 + rheight);
} // Function to Print Nodes from left to right static void leftToRight(Node root, int level)
{ if (root == null )
return ;
if (level == 1 )
System.out.print(root.data + " " );
else if (level > 1 )
{
leftToRight(root.left, level - 1 );
leftToRight(root.right, level - 1 );
}
} // Function to Print Nodes from right to left static void rightToLeft(Node root, int level)
{ if (root == null )
return ;
if (level == 1 )
System.out.print(root.data + " " );
else if (level > 1 )
{
rightToLeft(root.right, level - 1 );
rightToLeft(root.left, level - 1 );
}
} // Function to print anti clockwise spiral // traversal of a binary tree static void antiClockWiseSpiral(Node root)
{ int i = 1 ;
int j = height(root);
// Flag to mark a change in the direction
// of printing nodes
int flag = 0 ;
while (i <= j)
{
// If flag is zero print nodes
// from right to left
if (flag == 0 )
{
rightToLeft(root, i);
// Set the value of flag as zero
// so that nodes are next time
// printed from left to right
flag = 1 ;
// Increment i
i++;
}
// If flag is one print nodes
// from left to right
else {
leftToRight(root, j);
// Set the value of flag as zero
// so that nodes are next time
// printed from right to left
flag = 0 ;
// Decrement j
j--;
}
}
} // Driver code public static void main(String[] args)
{ Node root = new Node( 1 );
root.left = new Node( 2 );
root.right = new Node( 3 );
root.left.left = new Node( 4 );
root.right.left = new Node( 5 );
root.right.right = new Node( 7 );
root.left.left.left = new Node( 10 );
root.left.left.right = new Node( 11 );
root.right.right.left = new Node( 8 );
antiClockWiseSpiral(root);
} } // This code is contributed by Prerna Saini. |
# Python3 implementation of the approach # Binary tree node class newNode:
# Constructor to create a newNode
def __init__( self , data):
self .data = data
self .left = None
self .right = None
self .visited = False
# Recursive Function to find height # of binary tree def height(root):
# Base condition
if (root = = None ):
return 0
# Compute the height of each subtree
lheight = height(root.left)
rheight = height(root.right)
# Return the maximum of two
return max ( 1 + lheight, 1 + rheight)
# Function to Print Nodes from left to right def leftToRight(root, level):
if (root = = None ):
return
if (level = = 1 ):
print (root.data, end = " " )
elif (level > 1 ):
leftToRight(root.left, level - 1 )
leftToRight(root.right, level - 1 )
# Function to Print Nodes from right to left def rightToLeft(root, level):
if (root = = None ) :
return
if (level = = 1 ):
print (root.data, end = " " )
elif (level > 1 ):
rightToLeft(root.right, level - 1 )
rightToLeft(root.left, level - 1 )
# Function to print anti clockwise spiral # traversal of a binary tree def antiClockWiseSpiral(root):
i = 1
j = height(root)
# Flag to mark a change in the
# direction of printing nodes
flag = 0
while (i < = j):
# If flag is zero print nodes
# from right to left
if (flag = = 0 ):
rightToLeft(root, i)
# Set the value of flag as zero
# so that nodes are next time
# printed from left to right
flag = 1
# Increment i
i + = 1
# If flag is one print nodes
# from left to right
else :
leftToRight(root, j)
# Set the value of flag as zero
# so that nodes are next time
# printed from right to left
flag = 0
# Decrement j
j - = 1
# Driver Code if __name__ = = '__main__' :
root = newNode( 1 )
root.left = newNode( 2 )
root.right = newNode( 3 )
root.left.left = newNode( 4 )
root.right.left = newNode( 5 )
root.right.right = newNode( 7 )
root.left.left.left = newNode( 10 )
root.left.left.right = newNode( 11 )
root.right.right.left = newNode( 8 )
antiClockWiseSpiral(root)
# This code is contributed by # SHUBHAMSINGH10 |
// C# implementation of the approach using System;
class GFG
{ // Binary tree node public class Node
{ public Node left;
public Node right;
public int data;
public Node( int data)
{
this .data = data;
this .left = null ;
this .right = null ;
}
}; // Recursive Function to find height // of binary tree static int height( Node root)
{ // Base condition
if (root == null )
return 0;
// Compute the height of each subtree
int lheight = height(root.left);
int rheight = height(root.right);
// Return the maximum of two
return Math.Max(1 + lheight, 1 + rheight);
} // Function to Print Nodes from left to right static void leftToRight( Node root, int level)
{ if (root == null )
return ;
if (level == 1)
Console.Write( root.data + " " );
else if (level > 1)
{
leftToRight(root.left, level - 1);
leftToRight(root.right, level - 1);
}
} // Function to Print Nodes from right to left static void rightToLeft( Node root, int level)
{ if (root == null )
return ;
if (level == 1)
Console.Write( root.data + " " );
else if (level > 1)
{
rightToLeft(root.right, level - 1);
rightToLeft(root.left, level - 1);
}
} // Function to print anti clockwise spiral // traversal of a binary tree static void antiClockWiseSpiral( Node root)
{ int i = 1;
int j = height(root);
// Flag to mark a change in the direction
// of printing nodes
int flag = 0;
while (i <= j)
{
// If flag is zero print nodes
// from right to left
if (flag == 0)
{
rightToLeft(root, i);
// Set the value of flag as zero
// so that nodes are next time
// printed from left to right
flag = 1;
// Increment i
i++;
}
// If flag is one print nodes
// from left to right
else
{
leftToRight(root, j);
// Set the value of flag as zero
// so that nodes are next time
// printed from right to left
flag = 0;
// Decrement j
j--;
}
}
} // Driver code public static void Main(String []args)
{ Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.right.left = new Node(5);
root.right.right = new Node(7);
root.left.left.left = new Node(10);
root.left.left.right = new Node(11);
root.right.right.left = new Node(8);
antiClockWiseSpiral(root);
} } //This code is contributed by Arnab Kundu |
<script> // JavaScript implementation of the approach
// Binary tree node
class Node
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
// Recursive Function to find height
// of binary tree
function height(root)
{
// Base condition
if (root == null )
return 0;
// Compute the height of each subtree
let lheight = height(root.left);
let rheight = height(root.right);
// Return the maximum of two
return Math.max(1 + lheight, 1 + rheight);
}
// Function to Print Nodes from left to right
function leftToRight(root, level)
{
if (root == null )
return ;
if (level == 1)
document.write(root.data + " " );
else if (level > 1)
{
leftToRight(root.left, level - 1);
leftToRight(root.right, level - 1);
}
}
// Function to Print Nodes from right to left
function rightToLeft(root, level)
{
if (root == null )
return ;
if (level == 1)
document.write(root.data + " " );
else if (level > 1)
{
rightToLeft(root.right, level - 1);
rightToLeft(root.left, level - 1);
}
}
// Function to print anti clockwise spiral
// traversal of a binary tree
function antiClockWiseSpiral(root)
{
let i = 1;
let j = height(root);
// Flag to mark a change in the direction
// of printing nodes
let flag = 0;
while (i <= j)
{
// If flag is zero print nodes
// from right to left
if (flag == 0)
{
rightToLeft(root, i);
// Set the value of flag as zero
// so that nodes are next time
// printed from left to right
flag = 1;
// Increment i
i++;
}
// If flag is one print nodes
// from left to right
else {
leftToRight(root, j);
// Set the value of flag as zero
// so that nodes are next time
// printed from right to left
flag = 0;
// Decrement j
j--;
}
}
}
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.right.left = new Node(5);
root.right.right = new Node(7);
root.left.left.left = new Node(10);
root.left.left.right = new Node(11);
root.right.right.left = new Node(8);
antiClockWiseSpiral(root);
</script> |
Output:
1 10 11 8 3 2 4 5 7
Another Approach:
The above approach have O(n^2) worst case complexity due to calling the print level everytime. An improvement over it can be storing the level wise nodes and use it to print.
// C++ implementation of the above approach #include <bits/stdc++.h> using namespace std;
struct Node {
struct Node* left;
struct Node* right;
int data;
Node( int data)
{
this ->data = data;
this ->left = NULL;
this ->right = NULL;
}
}; void antiClockWiseSpiral( struct Node* root)
{ // Initialize the queue
queue<Node*> q;
// Add the root node
q.push(root);
// Initialize the vector
vector<Node*> topone;
// Until queue is not empty
while (!q.empty()) {
int len = q.size();
// len is greater than zero
while (len > 0) {
Node* nd = q.front();
q.pop();
if (nd != NULL) {
topone.push_back(nd);
if (nd->right != NULL)
q.push(nd->right);
if (nd->left != NULL)
q.push(nd->left);
}
len--;
}
topone.push_back(NULL);
}
bool top = true ;
int l = 0, r = ( int )topone.size() - 2;
while (l < r) {
if (top) {
while (l < ( int )topone.size()) {
Node* nd = topone[l++];
if (nd == NULL) {
break ;
}
cout << nd->data << " " ;
}
}
else {
while (r >= l) {
Node* nd = topone[r--];
if (nd == NULL)
break ;
cout << nd->data << " " ;
}
}
top = !top;
}
} // Build Tree int main()
{ /*
1
2 3
4 5 7
10 11 8
*/
struct Node* root = new Node(1);
root->left = new Node(2);
root->right = new Node(3);
root->left->left = new Node(4);
root->right->left = new Node(5);
root->right->right = new Node(7);
root->left->left->left = new Node(10);
root->left->left->right = new Node(11);
root->right->right->left = new Node(8);
antiClockWiseSpiral(root);
return 0;
} |
// Java implementation of the above approach import java.io.*;
import java.util.*;
class GFG {
// Structure of each node
class Node {
int val;
Node left, right;
Node( int val)
{
this .val = val;
this .left = this .right = null ;
}
}
private void work(Node root)
{
// Initialize queue
Queue<Node> q = new LinkedList<>();
// Add the root node
q.add(root);
// Initialize the vector
Vector<Node> topone = new Vector<>();
// Until queue is not empty
while (!q.isEmpty()) {
int len = q.size();
// len is greater than zero
while (len > 0 ) {
Node nd = q.poll();
if (nd != null ) {
topone.add(nd);
if (nd.right != null )
q.add(nd.right);
if (nd.left != null )
q.add(nd.left);
}
len--;
}
topone.add( null );
}
boolean top = true ;
int l = 0 , r = topone.size() - 2 ;
while (l < r) {
if (top) {
while (l < topone.size()) {
Node nd = topone.get(l++);
if (nd == null ) {
break ;
}
System.out.print(nd.val + " " );
}
}
else {
while (r >= l) {
Node nd = topone.get(r--);
if (nd == null )
break ;
System.out.print(nd.val + " " );
}
}
top = !top;
}
}
// Build Tree
public void solve()
{
/*
1
2 3
4 5 7
10 11 8
*/
Node root = new Node( 1 );
root.left = new Node( 2 );
root.right = new Node( 3 );
root.left.left = new Node( 4 );
root.right.left = new Node( 5 );
root.right.right = new Node( 7 );
root.left.left.left = new Node( 10 );
root.left.left.right = new Node( 11 );
root.right.right.left = new Node( 8 );
// Function call
work(root);
}
// Driver Code
public static void main(String[] args)
{
GFG t = new GFG();
t.solve();
}
} |
# Python 3 implementation of the above approach from collections import deque as dq
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def antiClockWiseSpiral(root):
# Initialize the queue
q = dq([root])
# Initialize the list
topone = []
# Until queue is not empty
while (q):
l = len (q)
# l is greater than zero
while (l > 0 ):
nd = q.popleft()
if (nd ! = None ):
topone.append(nd)
if (nd.right ! = None ):
q.append(nd.right)
if (nd.left ! = None ):
q.append(nd.left)
l - = 1
topone.append( None )
top = True
l = 0 ; r = len (topone) - 2
while (l < r):
if (top):
while (l < len (topone)):
nd = topone[l]
l + = 1
if (nd = = None ):
break
print (nd.data,end = " " )
else :
while (r > = l):
nd = topone[r]
r - = 1
if (nd = = None ):
break
print (nd.data,end = " " )
top = not top
print ()
# Build Tree if __name__ = = '__main__' :
# 1
# 2 3
# 4 5 7
# 10 11 8
root = Node( 1 )
root.left = Node( 2 )
root.right = Node( 3 )
root.left.left = Node( 4 )
root.right.left = Node( 5 )
root.right.right = Node( 7 )
root.left.left.left = Node( 10 )
root.left.left.right = Node( 11 )
root.right.right.left = Node( 8 )
antiClockWiseSpiral(root)
|
// C# implementation of the above approach using System;
using System.Collections;
using System.Collections.Generic;
public class GFG {
// Structure of each node
class Node {
public int val;
public Node left, right;
public Node( int val)
{
this .val = val;
this .left = this .right = null ;
}
}
private void work(Node root)
{
// Initialize queue
Queue q = new Queue();
// Add the root node
q.Enqueue(root);
// Initialize the vector
List<Node> topone = new List<Node>();
// Until queue is not empty
while (q.Count != 0) {
int len = q.Count;
// len is greater than zero
while (len > 0) {
Node nd = (Node)q.Dequeue();
if (nd != null ) {
topone.Add(nd);
if (nd.right != null )
q.Enqueue(nd.right);
if (nd.left != null )
q.Enqueue(nd.left);
}
len--;
}
topone.Add( null );
}
bool top = true ;
int l = 0, r = topone.Count - 2;
while (l < r) {
if (top) {
while (l < topone.Count) {
Node nd = topone[l++];
if (nd == null ) {
break ;
}
Console.Write(nd.val + " " );
}
}
else {
while (r >= l) {
Node nd = topone[r--];
if (nd == null )
break ;
Console.Write(nd.val + " " );
}
}
top = !top;
}
}
// Build Tree
public void solve()
{
/*
1
2 3
4 5 7
10 11 8
*/
Node root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.right.left = new Node(5);
root.right.right = new Node(7);
root.left.left.left = new Node(10);
root.left.left.right = new Node(11);
root.right.right.left = new Node(8);
// Function call
work(root);
}
static public void Main()
{
// Code
GFG t = new GFG();
t.solve();
}
} // This code is contributed by lokeshmvs21. |
<script> // JavaScript code to implement the above approach class Node { constructor(data){
this .data = data;
this .left = null , this .right = null ;
}
} function antiClockWiseSpiral(root){
// Initialize the queue
let q = [root]
// Initialize the list
let topone=[]
// Until queue is not empty
while (q.length>0){
let l = q.length
// l is greater than zero
while (l > 0){
let nd = q.shift()
if (nd != null ){
topone.push(nd)
if (nd.right != null )
q.push(nd.right)
if (nd.left != null )
q.push(nd.left)
}
l-=1
}
topone.push( null )
}
let top = true
let l = 0,r = topone.length - 2
while (l < r){
if (top){
while (l < topone.length){
let nd = topone[l]
l+=1
if (nd == null )
break
document.write(nd.data, " " )
}
}
else {
while (r >= l){
let nd = topone[r]
r-=1
if (nd == null )
break
document.write(nd.data, " " )
}
}
top = top^1
}
document.write( "</br>" )
} // driver code // Build Tree let root = new Node(1)
root.left = new Node(2)
root.right = new Node(3)
root.left.left = new Node(4)
root.right.left = new Node(5)
root.right.right = new Node(7)
root.left.left.left = new Node(10)
root.left.left.right = new Node(11)
root.right.right.left = new Node(8)
antiClockWiseSpiral(root) // code is contributed by shinjanpatra </script> |
Output:
1 10 11 8 3 2 4 5 7
Time Complexity: O(N)
Auxiliary Space: O(N)