Level order traversal with direction change after every two levels
Given a binary tree, print the level order traversal in such a way that first two levels are printed from left to right, next two levels are printed from right to left, then next two from left to right and so on. So, the problem is to reverse the direction of level order traversal of binary tree after every two levels.
Examples:
Input:
1
/ \
2 3
/ \ / \
4 5 6 7
/ \ / \ / \ / \
8 9 3 1 4 2 7 2
/ / \ \
16 17 18 19
Output:
1
2 3
7 6 5 4
2 7 2 4 1 3 9 8
16 17 18 19
In the above example, first two levels
are printed from left to right, next two
levels are printed from right to left,
and then last level is printed from
left to right.
Approach:
We make use of queue and stack here. Queue is used for performing normal level order traversal. Stack is used for reversing the direction of traversal after every two levels.
While doing normal level order traversal, first two levels nodes are printed at the time when they are popped out from the queue. For the next two levels, we instead of printing the nodes, pushed them onto the stack. When all nodes of current level are popped out, we print the nodes in the stack. In this way, we print the nodes in right to left order by making use of the stack. Now for the next two levels we again do normal level order traversal for printing nodes from left to right. Then for the next two nodes, we make use of the stack for achieving right to left order.
In this way, we will achieve desired modified level order traversal by making use of queue and stack.
C++
// CPP program to print Zig-Zag traversal// in groups of size 2.#include <iostream>#include <queue>#include <stack>using namespace std;// A Binary Tree Nodestruct Node { struct Node* left; int data; struct Node* right;};/* Function to print the level order of given binary tree. Direction of printing level order traversal of binary tree changes after every two levels */void modifiedLevelOrder(struct Node* node){ // For null root if (node == NULL) return; if (node->left == NULL && node->right == NULL) { cout << node->data; return; } // Maintain a queue for normal // level order traversal queue<Node*> myQueue; /* Maintain a stack for printing nodes in reverse order after they are popped out from queue.*/ stack<Node*> myStack; struct Node* temp = NULL; // sz is used for storing the count // of nodes in a level int sz; // Used for changing the direction // of level order traversal int ct = 0; // Used for changing the direction // of level order traversal bool rightToLeft = false; // Push root node to the queue myQueue.push(node); // Run this while loop till queue got empty while (!myQueue.empty()) { ct++; sz = myQueue.size(); // Do a normal level order traversal for (int i = 0; i < sz; i++) { temp = myQueue.front(); myQueue.pop(); /*For printing nodes from left to right, simply print the nodes in the order in which they are being popped out from the queue.*/ if (rightToLeft == false) cout << temp->data << " "; /* For printing nodes from right to left, push the nodes to stack instead of printing them.*/ else myStack.push(temp); if (temp->left) myQueue.push(temp->left); if (temp->right) myQueue.push(temp->right); } if (rightToLeft == true) { // for printing the nodes in order // from right to left while (!myStack.empty()) { temp = myStack.top(); myStack.pop(); cout << temp->data << " "; } } /*Change the direction of printing nodes after every two levels.*/ if (ct == 2) { rightToLeft = !rightToLeft; ct = 0; } cout << "\n"; }}// Utility function to create a new tree nodeNode* newNode(int data){ Node* temp = new Node; temp->data = data; temp->left = temp->right = NULL; return temp;}// Driver program to test above functionsint main(){ // Let us create binary tree Node* root = newNode(1); root->left = newNode(2); root->right = newNode(3); root->left->left = newNode(4); root->left->right = newNode(5); root->right->left = newNode(6); root->right->right = newNode(7); root->left->left->left = newNode(8); root->left->left->right = newNode(9); root->left->right->left = newNode(3); root->left->right->right = newNode(1); root->right->left->left = newNode(4); root->right->left->right = newNode(2); root->right->right->left = newNode(7); root->right->right->right = newNode(2); root->left->right->left->left = newNode(16); root->left->right->left->right = newNode(17); root->right->left->right->left = newNode(18); root->right->right->left->right = newNode(19); modifiedLevelOrder(root); return 0;} |
Java
// Java program to print Zig-Zag traversal// in groups of size 2.import java.util.*;class GFG {// A Binary Tree Nodestatic class Node { Node left; int data; Node right;};/* Function to print the level order of given binary tree. Direction of printing level order traversal of binary tree changes after every two levels */static void modifiedLevelOrder(Node node){ // For null root if (node == null) return; if (node.left == null && node.right == null) { System.out.print(node.data); return; } // Maintain a queue for normal // level order traversal Queue<Node> myQueue = new LinkedList<>(); /* Maintain a stack for printing nodes in reverse order after they are popped out from queue.*/ Stack<Node> myStack = new Stack<>(); Node temp = null; // sz is used for storing // the count of nodes in a level int sz; // Used for changing the direction // of level order traversal int ct = 0; // Used for changing the direction // of level order traversal boolean rightToLeft = false; // Push root node to the queue myQueue.add(node); // Run this while loop till queue got empty while (!myQueue.isEmpty()) { ct++; sz = myQueue.size(); // Do a normal level order traversal for (int i = 0; i < sz; i++) { temp = myQueue.peek(); myQueue.remove(); /*For printing nodes from left to right, simply print the nodes in the order in which they are being popped out from the queue.*/ if (rightToLeft == false) System.out.print(temp.data + " "); /* For printing nodes from right to left, push the nodes to stack instead of printing them.*/ else myStack.push(temp); if (temp.left != null) myQueue.add(temp.left); if (temp.right != null) myQueue.add(temp.right); } if (rightToLeft == true) { // for printing the nodes in order // from right to left while (!myStack.isEmpty()) { temp = myStack.peek(); myStack.pop(); System.out.print(temp.data + " "); } } /*Change the direction of printing nodes after every two levels.*/ if (ct == 2) { rightToLeft = !rightToLeft; ct = 0; } System.out.print("\n"); }}// Utility function to create a new tree nodestatic Node newNode(int data){ Node temp = new Node(); temp.data = data; temp.left = temp.right = null; return temp;}// Driver Codepublic static void main(String[] args) { // Let us create binary tree Node root = newNode(1); root.left = newNode(2); root.right = newNode(3); root.left.left = newNode(4); root.left.right = newNode(5); root.right.left = newNode(6); root.right.right = newNode(7); root.left.left.left = newNode(8); root.left.left.right = newNode(9); root.left.right.left = newNode(3); root.left.right.right = newNode(1); root.right.left.left = newNode(4); root.right.left.right = newNode(2); root.right.right.left = newNode(7); root.right.right.right = newNode(2); root.left.right.left.left = newNode(16); root.left.right.left.right = newNode(17); root.right.left.right.left = newNode(18); root.right.right.left.right = newNode(19); modifiedLevelOrder(root);}}// This code is contributed by 29AjayKumar |
C#
// C# program to print Zig-Zag traversal// in groups of size 2.using System;using System.Collections.Generic; class GFG {// A Binary Tree Nodepublic class Node { public Node left; public int data; public Node right;};/* Function to print the level order of given binary tree. Direction of printing level order traversal of binary tree changes after every two levels */static void modifiedLevelOrder(Node node){ // For null root if (node == null) return; if (node.left == null && node.right == null) { Console.Write(node.data); return; } // Maintain a queue for // normal level order traversal Queue<Node> myQueue = new Queue<Node>(); /* Maintain a stack for printing nodes in reverse order after they are popped out from queue.*/ Stack<Node> myStack = new Stack<Node>(); Node temp = null; // sz is used for storing // the count of nodes in a level int sz; // Used for changing the direction // of level order traversal int ct = 0; // Used for changing the direction // of level order traversal bool rightToLeft = false; // Push root node to the queue myQueue.Enqueue(node); // Run this while loop // till queue got empty while (myQueue.Count != 0) { ct++; sz = myQueue.Count; // Do a normal level order traversal for (int i = 0; i < sz; i++) { temp = myQueue.Peek(); myQueue.Dequeue(); /* For printing nodes from left to right, simply print the nodes in the order in which they are being popped out from the queue.*/ if (rightToLeft == false) Console.Write(temp.data + " "); /* For printing nodes from right to left, push the nodes to stack instead of printing them.*/ else myStack.Push(temp); if (temp.left != null) myQueue.Enqueue(temp.left); if (temp.right != null) myQueue.Enqueue(temp.right); } if (rightToLeft == true) { // for printing the nodes in order // from right to left while (myStack.Count != 0) { temp = myStack.Peek(); myStack.Pop(); Console.Write(temp.data + " "); } } /*Change the direction of printing nodes after every two levels.*/ if (ct == 2) { rightToLeft = !rightToLeft; ct = 0; } Console.Write("\n"); }}// Utility function to create a new tree nodestatic Node newNode(int data){ Node temp = new Node(); temp.data = data; temp.left = temp.right = null; return temp;}// Driver Codepublic static void Main(String[] args) { // Let us create binary tree Node root = newNode(1); root.left = newNode(2); root.right = newNode(3); root.left.left = newNode(4); root.left.right = newNode(5); root.right.left = newNode(6); root.right.right = newNode(7); root.left.left.left = newNode(8); root.left.left.right = newNode(9); root.left.right.left = newNode(3); root.left.right.right = newNode(1); root.right.left.left = newNode(4); root.right.left.right = newNode(2); root.right.right.left = newNode(7); root.right.right.right = newNode(2); root.left.right.left.left = newNode(16); root.left.right.left.right = newNode(17); root.right.left.right.left = newNode(18); root.right.right.left.right = newNode(19); modifiedLevelOrder(root);}}// This code is contributed by Rajput-Ji |
Output
1 2 3 7 6 5 4 2 7 2 4 1 3 9 8 16 17 18 19
Time Complexity: Each node is traversed at most twice while doing level order traversal, so time complexity would be O(n).
Approach 2:
We make use of queue and stack here, but in a different way. Using macros #define ChangeDirection(Dir) ((Dir) = 1 – (Dir)). In following implementation directs the order of push operations in both queue or stack.
In this way, we will achieve desired modified level order traversal by making use of queue and stack.
CPP
// CPP program to print Zig-Zag traversal// in groups of size 2.#include <iostream>#include <stack>#include <queue>using namespace std;#define LEFT 0#define RIGHT 1#define ChangeDirection(Dir) ((Dir) = 1 - (Dir))// A Binary Tree Nodestruct node { int data; struct node *left, *right;};// Utility function to create a new tree node node* newNode(int data) { node* temp = new node; temp->data = data; temp->left = temp->right = NULL; return temp; } /* Function to print the level order of given binary tree. Direction of printing level order traversal of binary tree changes after every two levels */void modifiedLevelOrder(struct node *root){ if (!root) return ; int dir = LEFT; struct node *temp; queue <struct node *> Q; stack <struct node *> S; S.push(root); // Run this while loop till queue got empty while (!Q.empty() || !S.empty()) { while (!S.empty()) { temp = S.top(); S.pop(); cout << temp->data << " "; if (dir == LEFT) { if (temp->left) Q.push(temp->left); if (temp->right) Q.push(temp->right); } /* For printing nodes from right to left, push the nodes to stack instead of printing them.*/ else { if (temp->right) Q.push(temp->right); if (temp->left) Q.push(temp->left); } } cout << endl; // for printing the nodes in order // from right to left while (!Q.empty()) { temp = Q.front(); Q.pop(); cout << temp->data << " "; if (dir == LEFT) { if (temp->left) S.push(temp->left); if (temp->right) S.push(temp->right); } else { if (temp->right) S.push(temp->right); if (temp->left) S.push(temp->left); } } cout << endl; // Change the direction of traversal. ChangeDirection(dir); }}// Driver program to test above functions int main() { // Let us create binary tree node* root = newNode(1); root->left = newNode(2); root->right = newNode(3); root->left->left = newNode(4); root->left->right = newNode(5); root->right->left = newNode(6); root->right->right = newNode(7); root->left->left->left = newNode(8); root->left->left->right = newNode(9); root->left->right->left = newNode(3); root->left->right->right = newNode(1); root->right->left->left = newNode(4); root->right->left->right = newNode(2); root->right->right->left = newNode(7); root->right->right->right = newNode(2); root->left->right->left->left = newNode(16); root->left->right->left->right = newNode(17); root->right->left->right->left = newNode(18); root->right->right->left->right = newNode(19); modifiedLevelOrder(root); return 0; } |
Java
// JAVA program to print Zig-Zag traversal// in groups of size 2.import java.util.*;class GFG{static final int LEFT = 0;static final int RIGHT = 1;static int ChangeDirection(int Dir){ Dir = 1 - Dir;return Dir;}// A Binary Tree Nodestatic class node { int data; node left, right;};// Utility function to create a new tree node static node newNode(int data) { node temp = new node(); temp.data = data; temp.left = temp.right = null; return temp; } /* Function to print the level order of given binary tree. Direction of printing level order traversal of binary tree changes after every two levels */static void modifiedLevelOrder(node root){ if (root == null) return ; int dir = LEFT; node temp; Queue <node > Q = new LinkedList<>(); Stack <node > S = new Stack<>(); S.add(root); // Run this while loop till queue got empty while (!Q.isEmpty() || !S.isEmpty()) { while (!S.isEmpty()) { temp = S.peek(); S.pop(); System.out.print(temp.data + " "); if (dir == LEFT) { if (temp.left != null) Q.add(temp.left); if (temp.right != null) Q.add(temp.right); } /* For printing nodes from right to left, push the nodes to stack instead of printing them.*/ else { if (temp.right != null) Q.add(temp.right); if (temp.left != null) Q.add(temp.left); } } System.out.println(); // for printing the nodes in order // from right to left while (!Q.isEmpty()) { temp = Q.peek(); Q.remove(); System.out.print(temp.data + " "); if (dir == LEFT) { if (temp.left != null) S.add(temp.left); if (temp.right != null) S.add(temp.right); } else { if (temp.right != null) S.add(temp.right); if (temp.left != null) S.add(temp.left); } } System.out.println(); // Change the direction of traversal. dir = ChangeDirection(dir); }}// Driver code public static void main(String[] args) { // Let us create binary tree node root = newNode(1); root.left = newNode(2); root.right = newNode(3); root.left.left = newNode(4); root.left.right = newNode(5); root.right.left = newNode(6); root.right.right = newNode(7); root.left.left.left = newNode(8); root.left.left.right = newNode(9); root.left.right.left = newNode(3); root.left.right.right = newNode(1); root.right.left.left = newNode(4); root.right.left.right = newNode(2); root.right.right.left = newNode(7); root.right.right.right = newNode(2); root.left.right.left.left = newNode(16); root.left.right.left.right = newNode(17); root.right.left.right.left = newNode(18); root.right.right.left.right = newNode(19); modifiedLevelOrder(root); } }// This code is contributed by Rajput-Ji |
C#
// C# program to print Zig-Zag traversal// in groups of size 2.using System;using System.Collections.Generic;public class GFG{static readonly int LEFT = 0;static readonly int RIGHT = 1;static int ChangeDirection(int Dir){ Dir = 1 - Dir;return Dir;}// A Binary Tree Nodepublic class node { public int data; public node left, right;};// Utility function to create a new tree node static node newNode(int data) { node temp = new node(); temp.data = data; temp.left = temp.right = null; return temp; } /* Function to print the level order of given binary tree. Direction of printing level order traversal of binary tree changes after every two levels */static void modifiedLevelOrder(node root){ if (root == null) return ; int dir = LEFT; node temp; Queue <node > Q = new Queue<node>(); Stack <node > S = new Stack<node>(); S.Push(root); // Run this while loop till queue got empty while (Q.Count!=0 || S.Count!=0) { while (S.Count!=0) { temp = S.Peek(); S.Pop(); Console.Write(temp.data + " "); if (dir == LEFT) { if (temp.left != null) Q.Enqueue(temp.left); if (temp.right != null) Q.Enqueue(temp.right); } /* For printing nodes from right to left, push the nodes to stack instead of printing them.*/ else { if (temp.right != null) Q.Enqueue(temp.right); if (temp.left != null) Q.Enqueue(temp.left); } } Console.WriteLine(); // for printing the nodes in order // from right to left while (Q.Count!=0) { temp = Q.Peek(); Q.Dequeue(); Console.Write(temp.data + " "); if (dir == LEFT) { if (temp.left != null) S.Push(temp.left); if (temp.right != null) S.Push(temp.right); } else { if (temp.right != null) S.Push(temp.right); if (temp.left != null) S.Push(temp.left); } } Console.WriteLine(); // Change the direction of traversal. dir = ChangeDirection(dir); }}// Driver code public static void Main(String[] args) { // Let us create binary tree node root = newNode(1); root.left = newNode(2); root.right = newNode(3); root.left.left = newNode(4); root.left.right = newNode(5); root.right.left = newNode(6); root.right.right = newNode(7); root.left.left.left = newNode(8); root.left.left.right = newNode(9); root.left.right.left = newNode(3); root.left.right.right = newNode(1); root.right.left.left = newNode(4); root.right.left.right = newNode(2); root.right.right.left = newNode(7); root.right.right.right = newNode(2); root.left.right.left.left = newNode(16); root.left.right.left.right = newNode(17); root.right.left.right.left = newNode(18); root.right.right.left.right = newNode(19); modifiedLevelOrder(root); } }// This code contributed by Rajput-Ji |
Output
1 2 3 7 6 5 4 2 7 2 4 1 3 9 8 16 17 18 19
Time Complexity: every node is also traversed twice. There time complexity is still O(n).
Alternative Approach (using recursion)
We make use of recursion and an additional stack to solve the problem. This solution looks simpler.
Python3
# Python program for above approach# Node classclass Node: def __init__(self, key): self.left = None self.right = None self.key = key# Function to calculate heightdef heightTree(root): # Check if root is None if root is None: return 0 else: lheight = heightTree(root.left) rheight = heightTree(root.right) # Check greater between # lheight and rheight if lheight > rheight: return 1 + lheight else: return 1 + rheight# Function to print 2 levelsdef print_2_levels(root): # Check if root is None if root is None: return height = heightTree(root) count = 0 # Iterate from 1 to height for i in range(1, height+1): global stack_struct stack_struct = [] # Check is count is less than 2 if count < 2: print_level(root, i, stack=False) else: print_level(root, i, stack=True) # Iterate backwards from len(stack_struct)-1 # till 0 for i in range(len(stack_struct)-1, -1, -1): print(stack_struct[i], end=' ') if count == 3: count = -1 # Increment Counter count += 1 print("")# Function to print leveldef print_level(root, level, stack=False): global stack_struct # Check if root is None if root is None: return # Check is level is 1 and stack is False if level == 1 and stack == False: print(root.key, end=' ') # Check if level is 1 and stack is True elif level == 1 and stack == True: stack_struct.append(root.key) # Check if level is greater than 1 elif level > 1: print_level(root.left, level-1, stack=stack) print_level(root.right, level-1, stack=stack) # Driver Coderoot = Node(1)root.left = Node(2)root.right = Node(3)root.left.left = Node(4)root.left.right = Node(5)root.right.left = Node(6)root.right.right = Node(7)root.left.left.left = Node(8)root.left.left.right = Node(9)root.left.right.left = Node(3)root.left.right.right = Node(1)root.right.left.left = Node(4)root.right.left.right = Node(2)root.right.right.left = Node(7)root.right.right.right = Node(2)root.left.left.right.left = Node(16)root.left.right.right.left = Node(17)root.left.right.right.right = Node(18)root.right.left.right.right = Node(19)print("Different levels:")# Function Callprint_2_levels(root) |
Output
Different levels: 1 2 3 7 6 5 4 2 7 2 4 1 3 9 8 16 17 18 19
Time Complexity: O(n^2).
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.
