Level order traversal in spiral form

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

spiral_order

Method 1 (Recursive)
This problem can be seen as an extension of the level order traversal post.
To print the nodes in spiral order, nodes at different levels should be printed in alternating order. An additional Boolean variable ltr is used to change printing order of levels. If ltr is 1 then printGivenLevel() prints nodes from left to right else from right to left. Value of ltr is flipped in each iteration to change the order.

Function to print level order traversal of tree


printSpiral(tree)
  bool ltr = 0;
  for d = 1 to height(tree)
     printGivenLevel(tree, d, ltr);
     ltr ~= ltr /*flip ltr*/

Function to print all nodes at a given level

printGivenLevel(tree, level, ltr)
if tree is NULL then return;
if level is 1, then
    print(tree->data);
else if level greater than 1, then
    if(ltr)
        printGivenLevel(tree->left, level-1, ltr);
        printGivenLevel(tree->right, level-1, ltr);
    else
        printGivenLevel(tree->right, level-1, ltr);
        printGivenLevel(tree->left, level-1, ltr);

Following is the implementation of above algorithm.

C

filter_none

edit
close

play_arrow

link
brightness_4
code

// C program for recursive level order traversal in spiral form
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
  
/* A binary tree node has data, pointer to left child
   and a pointer to right child */
struct node {
    int data;
    struct node* left;
    struct node* right;
};
  
/* Function protoypes */
void printGivenLevel(struct node* root, int level, int ltr);
int height(struct node* node);
struct node* newNode(int data);
  
/* Function to print spiral traversal of a tree*/
void printSpiral(struct node* root)
{
    int h = height(root);
    int i;
  
    /*ltr -> Left to Right. If this variable is set,
      then the given level is traversed from left to right. */
    bool ltr = false;
    for (i = 1; i <= h; i++) {
        printGivenLevel(root, i, ltr);
  
        /*Revert ltr to traverse next level in opposite order*/
        ltr = !ltr;
    }
}
  
/* Print nodes at a given level */
void printGivenLevel(struct node* root, int level, int ltr)
{
    if (root == NULL)
        return;
    if (level == 1)
        printf("%d ", root->data);
    else if (level > 1) {
        if (ltr) {
            printGivenLevel(root->left, level - 1, ltr);
            printGivenLevel(root->right, level - 1, ltr);
        }
        else {
            printGivenLevel(root->right, level - 1, ltr);
            printGivenLevel(root->left, level - 1, ltr);
        }
    }
}
  
/* Compute the "height" of a tree -- the number of
    nodes along the longest path from the root node
    down to the farthest leaf node.*/
int height(struct node* node)
{
    if (node == NULL)
        return 0;
    else {
        /* compute the height of each subtree */
        int lheight = height(node->left);
        int rheight = height(node->right);
  
        /* use the larger one */
        if (lheight > rheight)
            return (lheight + 1);
        else
            return (rheight + 1);
    }
}
  
/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
struct node* newNode(int data)
{
    struct node* node = (struct node*)
        malloc(sizeof(struct node));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
  
    return (node);
}
  
/* Driver program to test above functions*/
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);
    printf("Spiral Order traversal of binary tree is \n");
    printSpiral(root);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for recursive level order traversal in spiral form
  
/* A binary tree node has data, pointer to left child 
   and a pointer to right child */
class Node {
    int data;
    Node left, right;
  
    public Node(int d)
    {
        data = d;
        left = right = null;
    }
}
  
class BinaryTree {
    Node root;
  
    // Function to print the spiral traversal of tree
    void printSpiral(Node node)
    {
        int h = height(node);
        int i;
  
        /* ltr -> left to right. If this variable is set then the
           given label is traversed from left to right */
        boolean ltr = false;
        for (i = 1; i <= h; i++) {
            printGivenLevel(node, i, ltr);
  
            /*Revert ltr to traverse next level in opposite order*/
            ltr = !ltr;
        }
    }
  
    /* Compute the "height" of a tree -- the number of
    nodes along the longest path from the root node
    down to the farthest leaf node.*/
    int height(Node node)
    {
        if (node == null)
            return 0;
        else {
  
            /* compute the height of each subtree */
            int lheight = height(node.left);
            int rheight = height(node.right);
  
            /* use the larger one */
            if (lheight > rheight)
                return (lheight + 1);
            else
                return (rheight + 1);
        }
    }
  
    /* Print nodes at a given level */
    void printGivenLevel(Node node, int level, boolean ltr)
    {
        if (node == null)
            return;
        if (level == 1)
            System.out.print(node.data + " ");
        else if (level > 1) {
            if (ltr != false) {
                printGivenLevel(node.left, level - 1, ltr);
                printGivenLevel(node.right, level - 1, ltr);
            }
            else {
                printGivenLevel(node.right, level - 1, ltr);
                printGivenLevel(node.left, level - 1, ltr);
            }
        }
    }
    /* Driver program to test the above functions */
    public static void main(String[] args)
    {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(7);
        tree.root.left.right = new Node(6);
        tree.root.right.left = new Node(5);
        tree.root.right.right = new Node(4);
        System.out.println("Spiral order traversal of Binary Tree is ");
        tree.printSpiral(tree.root);
    }
}
  
// This code has been contributed by Mayank Jaiswal(mayank_24)

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for recursive level order
# traversal in spiral form 
  
class newNode: 
  
    # Construct to create a newNode 
    def __init__(self, key): 
        self.data = key 
        self.left = None
        self.right = None
  
""" Function to print spiral traversal of a tree"""
def printSpiral(root):
  
    h = height(root) 
      
    """ltr Left to Right. If this variable 
    is set, then the given level is traversed
    from left to right. """
    ltr = False
    for i in range(1, h + 1):
      
        printGivenLevel(root, i, ltr) 
  
        """Revert ltr to traverse next level
           in opposite order"""
        ltr = not ltr 
      
""" Print nodes at a given level """
def printGivenLevel(root, level, ltr):
  
    if(root == None):
        return
    if(level == 1):
        print(root.data, end = " "
    elif (level > 1):
      
        if(ltr):
            printGivenLevel(root.left, level - 1, ltr) 
            printGivenLevel(root.right, level - 1, ltr) 
          
        else:
            printGivenLevel(root.right, level - 1, ltr) 
            printGivenLevel(root.left, level - 1, ltr) 
          
""" Compute the "height" of a tree -- the number of 
    nodes along the longest path from the root node 
    down to the farthest leaf node."""
def height(node):
  
    if (node == None):
        return 0
    else:
      
        """ compute the height of each subtree """
        lheight = height(node.left) 
        rheight = height(node.right) 
  
        """ use the larger one """
        if (lheight > rheight):
            return(lheight + 1
        else:
            return(rheight + 1
      
# Driver Code
if __name__ == '__main__':
    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
    print("Spiral Order traversal of binary tree is"
    printSpiral(root) 
      
# This code is contributed
# by SHUBHAMSINGH10

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for recursive level
// order traversal in spiral form
using System;
  
/* A binary tree node has data, 
pointer to left child and a 
pointer to right child */
public class Node {
    public int data;
    public Node left, right;
  
    public Node(int d)
    {
        data = d;
        left = right = null;
    }
}
  
class GFG {
    public Node root;
  
    // Function to print the spiral
    // traversal of tree
    public virtual void printSpiral(Node node)
    {
        int h = height(node);
        int i;
  
        /* ltr -> left to right. If this 
        variable is set then the given
        label is traversed from left to right */
        bool ltr = false;
        for (i = 1; i <= h; i++) {
            printGivenLevel(node, i, ltr);
  
            /*Revert ltr to traverse next 
              level in opposite order*/
            ltr = !ltr;
        }
    }
  
    /* Compute the "height" of a tree -- the
    number of nodes along the longest path 
    from the root node down to the farthest 
    leaf node.*/
    public virtual int height(Node node)
    {
        if (node == null) {
            return 0;
        }
        else {
  
            /* compute the height of each subtree */
            int lheight = height(node.left);
            int rheight = height(node.right);
  
            /* use the larger one */
            if (lheight > rheight) {
                return (lheight + 1);
            }
            else {
                return (rheight + 1);
            }
        }
    }
  
    /* Print nodes at a given level */
    public virtual void printGivenLevel(Node node,
                                        int level,
                                        bool ltr)
    {
        if (node == null) {
            return;
        }
        if (level == 1) {
            Console.Write(node.data + " ");
        }
        else if (level > 1) {
            if (ltr != false) {
                printGivenLevel(node.left, level - 1, ltr);
                printGivenLevel(node.right, level - 1, ltr);
            }
            else {
                printGivenLevel(node.right, level - 1, ltr);
                printGivenLevel(node.left, level - 1, ltr);
            }
        }
    }
  
    // Driver Code
    public static void Main(string[] args)
    {
        GFG tree = new GFG();
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(7);
        tree.root.left.right = new Node(6);
        tree.root.right.left = new Node(5);
        tree.root.right.right = new Node(4);
        Console.WriteLine("Spiral order traversal "
                          + "of Binary Tree is ");
        tree.printSpiral(tree.root);
    }
}
  
// This code is contributed by Shrikant13

chevron_right



Output:

Spiral Order traversal of binary tree is
1 2 3 4 5 6 7

Time Complexity: Worst case time complexity of the above method is O(n^2). Worst case occurs in case of skewed trees.



Method 2 (Iterative)
We can print spiral order traversal in O(n) time and O(n) extra space. The idea is to use two stacks. We can use one stack for printing from left to right and other stack for printing from right to left. In every iteration, we have nodes of one level in one of the stacks. We print the nodes, and push nodes of next level in other stack.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of a O(n) time method for spiral order traversal
#include <iostream>
#include <stack>
using namespace std;
  
// Binary Tree node
struct node {
    int data;
    struct node *left, *right;
};
  
void printSpiral(struct node* root)
{
    if (root == NULL)
        return; // NULL check
  
    // Create two stacks to store alternate levels
    stack<struct node*> s1; // For levels to be printed from right to left
    stack<struct node*> s2; // For levels to be printed from left to right
  
    // Push first level to first stack 's1'
    s1.push(root);
  
    // Keep printing while any of the stacks has some nodes
    while (!s1.empty() || !s2.empty()) {
        // Print nodes of current level from s1 and push nodes of
        // next level to s2
        while (!s1.empty()) {
            struct node* temp = s1.top();
            s1.pop();
            cout << temp->data << " ";
  
            // Note that is right is pushed before left
            if (temp->right)
                s2.push(temp->right);
            if (temp->left)
                s2.push(temp->left);
        }
  
        // Print nodes of current level from s2 and push nodes of
        // next level to s1
        while (!s2.empty()) {
            struct node* temp = s2.top();
            s2.pop();
            cout << temp->data << " ";
  
            // Note that is left is pushed before right
            if (temp->left)
                s1.push(temp->left);
            if (temp->right)
                s1.push(temp->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 = NULL;
    node->right = NULL;
  
    return (node);
}
  
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);
    cout << "Spiral Order traversal of binary tree is \n";
    printSpiral(root);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of an O(n) approach of level order
// traversal in spiral form
  
import java.util.*;
  
// A Binary Tree node
class Node {
    int data;
    Node left, right;
  
    public Node(int item)
    {
        data = item;
        left = right = null;
    }
}
  
class BinaryTree {
  
    static Node root;
  
    void printSpiral(Node node)
    {
        if (node == null)
            return; // NULL check
  
        // Create two stacks to store alternate levels
        // For levels to be printed from right to left
        Stack<Node> s1 = new Stack<Node>(); 
        // For levels to be printed from left to right
        Stack<Node> s2 = new Stack<Node>(); 
  
        // Push first level to first stack 's1'
        s1.push(node);
  
        // Keep printing while any of the stacks has some nodes
        while (!s1.empty() || !s2.empty()) {
            // Print nodes of current level from s1 and push nodes of
            // next level to s2
            while (!s1.empty()) {
                Node temp = s1.peek();
                s1.pop();
                System.out.print(temp.data + " ");
  
                // Note that is right is pushed before left
                if (temp.right != null)
                    s2.push(temp.right);
  
                if (temp.left != null)
                    s2.push(temp.left);
            }
  
            // Print nodes of current level from s2 and push nodes of
            // next level to s1
            while (!s2.empty()) {
                Node temp = s2.peek();
                s2.pop();
                System.out.print(temp.data + " ");
  
                // Note that is left is pushed before right
                if (temp.left != null)
                    s1.push(temp.left);
                if (temp.right != null)
                    s1.push(temp.right);
            }
        }
    }
  
    public static void main(String[] args)
    {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(1);
        tree.root.left = new Node(2);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(7);
        tree.root.left.right = new Node(6);
        tree.root.right.left = new Node(5);
        tree.root.right.right = new Node(4);
        System.out.println("Spiral Order traversal of Binary Tree is ");
        tree.printSpiral(root);
    }
}
  
// This code has been contributed by Mayank Jaiswal(mayank_24)

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of a O(n) time 
# method for spiral order traversal 
  
# A class to create a new node 
class newNode:
    def __init__(self, data):
        self.data = data 
        self.left = None
        self.right = None
  
def printSpiral(root):
    if (root == None):
        return # None check 
  
    # Create two stacks to store 
    # alternate levels 
    s1 = [] # For levels to be printed 
            # from right to left 
    s2 = [] # For levels to be printed 
            # from left to right 
  
    # append first level to first stack 's1' 
    s1.append(root) 
  
    # Keep printing while any of the 
    # stacks has some nodes 
    while not len(s1) == 0 or not len(s2) == 0:
          
        # Print nodes of current level from s1 
        # and append nodes of next level to s2 
        while not len(s1) == 0:
            temp = s1[-1
            s1.pop() 
            print(temp.data, end = " "
  
            # Note that is right is appended
            # before left 
            if (temp.right): 
                s2.append(temp.right) 
            if (temp.left):
                s2.append(temp.left)
  
        # Print nodes of current level from s2 
        # and append nodes of next level to s1 
        while (not len(s2) == 0):
            temp = s2[-1
            s2.pop() 
            print(temp.data, end = " "
  
            # Note that is left is appended
            # before right 
            if (temp.left):
                s1.append(temp.left) 
            if (temp.right): 
                s1.append(temp.right)
  
# Driver Code
if __name__ == '__main__':
    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
    print("Spiral Order traversal of",
                    "binary tree is "
    printSpiral(root)
  
# This code is contributed by PranchalK 

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of an O(n) approach of
// level order traversal in spiral form
using System;
using System.Collections.Generic;
  
// A Binary Tree node
public class Node {
    public int data;
    public Node left, right;
  
    public Node(int item)
    {
        data = item;
        left = right = null;
    }
}
  
public class BinaryTree {
    public static Node root;
  
    public virtual void printSpiral(Node node)
    {
        if (node == null) {
            return; // NULL check
        }
  
        // Create two stacks to store alternate levels
        Stack<Node> s1 = new Stack<Node>(); // For levels to be printed
        // from right to left
        Stack<Node> s2 = new Stack<Node>(); // For levels to be printed
        // from left to right
  
        // Push first level to first stack 's1'
        s1.Push(node);
  
        // Keep printing while any of the
        // stacks has some nodes
        while (s1.Count > 0 || s2.Count > 0) {
            // Print nodes of current level from
            // s1 and push nodes of next level to s2
            while (s1.Count > 0) {
                Node temp = s1.Peek();
                s1.Pop();
                Console.Write(temp.data + " ");
  
                // Note that is right is pushed before left
                if (temp.right != null) {
                    s2.Push(temp.right);
                }
  
                if (temp.left != null) {
                    s2.Push(temp.left);
                }
            }
  
            // Print nodes of current level from s2
            // and push nodes of next level to s1
            while (s2.Count > 0) {
                Node temp = s2.Peek();
                s2.Pop();
                Console.Write(temp.data + " ");
  
                // Note that is left is pushed before right
                if (temp.left != null) {
                    s1.Push(temp.left);
                }
                if (temp.right != null) {
                    s1.Push(temp.right);
                }
            }
        }
    }
  
    // Driver Code
    public static void Main(string[] args)
    {
        BinaryTree tree = new BinaryTree();
        BinaryTree.root = new Node(1);
        BinaryTree.root.left = new Node(2);
        BinaryTree.root.right = new Node(3);
        BinaryTree.root.left.left = new Node(7);
        BinaryTree.root.left.right = new Node(6);
        BinaryTree.root.right.left = new Node(5);
        BinaryTree.root.right.right = new Node(4);
        Console.WriteLine("Spiral Order traversal of Binary Tree is ");
        tree.printSpiral(root);
    }
}
  
// This code is contributed by Shrikant13

chevron_right



Output:

Spiral Order traversal of binary tree is
1 2 3 4 5 6 7



Please write comments if you find any bug in the above program/algorithm; or if you want to share more information about spiral traversal.



My Personal Notes arrow_drop_up