Given a binary tree, the task is to find the zigzag level order traversal of the tree. In zig zag traversal starting from the first level go from left to right for odd-numbered levels and right to left for even-numbered levels.
Using Recursion - O(n) Time and O(n) Space
The idea is to first calculate the height of the tree, then recursively traverse each level and print the level order traversal according to the current level being odd or even.
Refer to Zig-Zag traversal of a Binary Tree using Recursion for detailed explanation.
Using two stacks - O(n) Time and O(n) Space
The idea is to use two stacks. One stack will be used to traverse the current level and the other stack will be used to store the nodes of next level.
Step by step approach:
- Initialize two stacks:
s1 and s2, and push the root of the tree into s1. - While loop: Continue as long as either
s1 or s2 contains nodes.- Traverse
s1:- Pop the top node from
s1, and add to the result. - If the node has a left child, push it to
s2. - If the node has a right child, push it to
s2.
- Traverse
s2:- Pop the top node from
s2, and add to the result - If the node has a right child, push it to
s1. - If the node has a left child, push it to
s1.
- Alternating Directions: This traversal alternates as we first push right in s2 and first push left in s1.
C++
// C++ Program to traverse a binary
// tree in zigzag manner.
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int data;
Node *left;
Node *right;
Node(int x) {
data = x;
left = nullptr;
right = nullptr;
}
};
// function to print the zigzag traversal
vector<int> zigZagTraversal(Node* root) {
vector<int> res;
if (root == nullptr)
return res;
// Current level
stack<Node*> s1;
// Next level
stack<Node*> s2;
s1.push(root);
while (!s1.empty() || !s2.empty()) {
// Print nodes of current level from s1
// and push nodes of next level to s2
while (!s1.empty()) {
Node* curr = s1.top();
s1.pop();
res.push_back(curr->data);
if (curr->left)
s2.push(curr->left);
if (curr->right)
s2.push(curr->right);
}
// Print nodes of current level from s2
// and push nodes of next level to s1
while (!s2.empty()) {
Node* curr = s2.top();
s2.pop();
res.push_back(curr->data);
if (curr->right)
s1.push(curr->right);
if (curr->left)
s1.push(curr->left);
}
}
return res;
}
int main() {
// Create a hard coded tree.
// 20
// / \
// 8 22
// / \ \
// 4 12 11
// / \
// 10 14
Node* root = new Node(20);
root->left = new Node(8);
root->right = new Node(22);
root->right->right = new Node(11);
root->left->left = new Node(4);
root->left->right = new Node(12);
root->left->right->left = new Node(10);
root->left->right->right = new Node(14);
vector<int> res = zigZagTraversal(root);
for (auto val: res) cout << val << " ";
cout << endl;
return 0;
}
// Java Program to traverse a binary
// tree in zigzag manner.
import java.util.*;
class Node {
int data;
Node left;
Node right;
Node(int x) {
data = x;
left = null;
right = null;
}
}
class GfG {
// function to print the zigzag traversal
static ArrayList<Integer> zigZagTraversal(Node root) {
ArrayList<Integer> res = new ArrayList<>();
if (root == null)
return res;
// Current level
Stack<Node> s1 = new Stack<>();
// Next level
Stack<Node> s2 = new Stack<>();
s1.push(root);
while (!s1.empty() || !s2.empty()) {
// Print nodes of current level from s1
// and push nodes of next level to s2
while (!s1.empty()) {
Node curr = s1.pop();
res.add(curr.data);
if (curr.left != null)
s2.push(curr.left);
if (curr.right != null)
s2.push(curr.right);
}
// Print nodes of current level from s2
// and push nodes of next level to s1
while (!s2.empty()) {
Node curr = s2.pop();
res.add(curr.data);
if (curr.right != null)
s1.push(curr.right);
if (curr.left != null)
s1.push(curr.left);
}
}
return res;
}
public static void main(String[] args) {
// Create a hard coded tree.
// 20
// / \
// 8 22
// / \ \
// 4 12 11
// / \
// 10 14
Node root = new Node(20);
root.left = new Node(8);
root.right = new Node(22);
root.right.right = new Node(11);
root.left.left = new Node(4);
root.left.right = new Node(12);
root.left.right.left = new Node(10);
root.left.right.right = new Node(14);
ArrayList<Integer> res = zigZagTraversal(root);
for (int val : res) System.out.print(val + " ");
System.out.println();
}
}
# Python Program to traverse a binary
# tree in zigzag manner.
class Node:
def __init__(self, x):
self.data = x
self.left = None
self.right = None
# function to print the zigzag traversal
def zigZagTraversal(root):
res = []
if root is None:
return res
# Current level
s1 = []
# Next level
s2 = []
s1.append(root)
while s1 or s2:
# Print nodes of current level from s1
# and push nodes of next level to s2
while s1:
curr = s1.pop()
res.append(curr.data)
if curr.left:
s2.append(curr.left)
if curr.right:
s2.append(curr.right)
# Print nodes of current level from s2
# and push nodes of next level to s1
while s2:
curr = s2.pop()
res.append(curr.data)
if curr.right:
s1.append(curr.right)
if curr.left:
s1.append(curr.left)
return res
if __name__ == "__main__":
# Create a hard coded tree.
# 20
# / \
# 8 22
# / \ \
# 4 12 11
# / \
# 10 14
root = Node(20)
root.left = Node(8)
root.right = Node(22)
root.right.right = Node(11)
root.left.left = Node(4)
root.left.right = Node(12)
root.left.right.left = Node(10)
root.left.right.right = Node(14)
res = zigZagTraversal(root)
for val in res: print(val, end=" ")
print()
// C# Program to traverse a binary
// tree in zigzag manner.
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left;
public Node right;
public Node(int x) {
data = x;
left = null;
right = null;
}
}
class GfG {
// function to print the zigzag traversal
static List<int> zigZagTraversal(Node root) {
List<int> res = new List<int>();
if (root == null)
return res;
// Current level
Stack<Node> s1 = new Stack<Node>();
// Next level
Stack<Node> s2 = new Stack<Node>();
s1.Push(root);
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 curr = s1.Pop();
res.Add(curr.data);
if (curr.left != null)
s2.Push(curr.left);
if (curr.right != null)
s2.Push(curr.right);
}
// Print nodes of current level from s2
// and push nodes of next level to s1
while (s2.Count > 0) {
Node curr = s2.Pop();
res.Add(curr.data);
if (curr.right != null)
s1.Push(curr.right);
if (curr.left != null)
s1.Push(curr.left);
}
}
return res;
}
static void Main() {
// Create a hard coded tree.
// 20
// / \
// 8 22
// / \ \
// 4 12 11
// / \
// 10 14
Node root = new Node(20);
root.left = new Node(8);
root.right = new Node(22);
root.right.right = new Node(11);
root.left.left = new Node(4);
root.left.right = new Node(12);
root.left.right.left = new Node(10);
root.left.right.right = new Node(14);
List<int> res = zigZagTraversal(root);
foreach (int val in res) Console.Write(val + " ");
Console.WriteLine();
}
}
// JavaScript Program to traverse a binary
// tree in zigzag manner.
class Node {
constructor(x) {
this.data = x;
this.left = null;
this.right = null;
}
}
// function to print the zigzag traversal
function zigZagTraversal(root) {
let res = [];
if (root == null)
return res;
// Current level
let s1 = [];
// Next level
let s2 = [];
s1.push(root);
while (s1.length > 0 || s2.length > 0) {
// Print nodes of current level from s1
// and push nodes of next level to s2
while (s1.length > 0) {
let curr = s1.pop();
res.push(curr.data);
if (curr.left)
s2.push(curr.left);
if (curr.right)
s2.push(curr.right);
}
// Print nodes of current level from s2
// and push nodes of next level to s1
while (s2.length > 0) {
let curr = s2.pop();
res.push(curr.data);
if (curr.right)
s1.push(curr.right);
if (curr.left)
s1.push(curr.left);
}
}
return res;
}
// Create a hard coded tree.
// 20
// / \
// 8 22
// / \ \
// 4 12 11
// / \
// 10 14
let root = new Node(20);
root.left = new Node(8);
root.right = new Node(22);
root.right.right = new Node(11);
root.left.left = new Node(4);
root.left.right = new Node(12);
root.left.right.left = new Node(10);
root.left.right.right = new Node(14);
let res = zigZagTraversal(root);
console.log(res.join(" "));
Output20 22 8 4 12 11 14 10
Time Complexity: O(n), where n is the number of nodes in the tree.
Auxiliary Space: O(n), considering both the output vector and the maximum width of the tree.
Using Deque - O(n) Time and O(n) Space
The idea is to use Doubly Ended Queues, then push and pop the nodes from each end in alternate order.
Step by step approach:
- Initialize a deque
dq and push the root of the binary tree into it. - Set
reverse = false, i.e., we will begin from the front of the deque. - While the deque is not empty, repeat the following:
- Set
n = dq.size(). - If
reverse is false, do the following:- For n nodes in the deque, pop from the front and push the node's value into result.
- If the left child exists, push it to the back of the deque.
- If the right child exists, push it to the back of the deque.
- After processing the level, set
reverse = !reverse.
- If
reverse is true, do the following:- For n nodes in the deque, pop from the back and push the node's value into result.
- If the right child exists, push it to the front of the deque.
- If the left child exists, push it to the front of the deque.
- After processing the level, set
reverse = !reverse.
C++
// C++ Program to traverse a binary
// tree in zigzag manner.
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int data;
Node *left;
Node *right;
Node(int x) {
data = x;
left = nullptr;
right = nullptr;
}
};
// function to print the zigzag traversal
vector<int> zigZagTraversal(Node* root) {
vector<int> res;
if (!root) return res;
deque<Node*> dq;
dq.push_back(root);
bool reverse = false;
while (!dq.empty()) {
int n = dq.size();
while (n--) {
// Push right first if reverse is true
if (reverse) {
Node* curr = dq.back();
dq.pop_back();
res.push_back(curr->data);
if (curr->right) dq.push_front(curr->right);
if (curr->left) dq.push_front(curr->left);
}
// Else push left first
else {
Node* curr = dq.front();
dq.pop_front();
res.push_back(curr->data);
if (curr->left) dq.push_back(curr->left);
if (curr->right) dq.push_back(curr->right);
}
}
reverse = !reverse;
}
return res;
}
int main() {
// Create a hard coded tree.
// 20
// / \
// 8 22
// / \ \
// 4 12 11
// / \
// 10 14
Node* root = new Node(20);
root->left = new Node(8);
root->right = new Node(22);
root->right->right = new Node(11);
root->left->left = new Node(4);
root->left->right = new Node(12);
root->left->right->left = new Node(10);
root->left->right->right = new Node(14);
vector<int> res = zigZagTraversal(root);
for (auto val: res) cout << val << " ";
cout << endl;
return 0;
}
// Java Program to traverse a binary
// tree in zigzag manner.
import java.util.*;
class Node {
int data;
Node left;
Node right;
Node(int x) {
data = x;
left = null;
right = null;
}
}
class GfG {
// function to print the zigzag traversal
static ArrayList<Integer> zigZagTraversal(Node root) {
ArrayList<Integer> res = new ArrayList<>();
if (root == null) return res;
Deque<Node> dq = new LinkedList<>();
dq.addLast(root);
boolean reverse = false;
while (!dq.isEmpty()) {
int n = dq.size();
while (n-- > 0) {
// Push right first if reverse is true
if (reverse) {
Node curr = dq.removeLast();
res.add(curr.data);
if (curr.right != null) dq.addFirst(curr.right);
if (curr.left != null) dq.addFirst(curr.left);
}
// Else push left first
else {
Node curr = dq.removeFirst();
res.add(curr.data);
if (curr.left != null) dq.addLast(curr.left);
if (curr.right != null) dq.addLast(curr.right);
}
}
reverse = !reverse;
}
return res;
}
public static void main(String[] args) {
// Create a hard coded tree.
// 20
// / \
// 8 22
// / \ \
// 4 12 11
// / \
// 10 14
Node root = new Node(20);
root.left = new Node(8);
root.right = new Node(22);
root.right.right = new Node(11);
root.left.left = new Node(4);
root.left.right = new Node(12);
root.left.right.left = new Node(10);
root.left.right.right = new Node(14);
ArrayList<Integer> res = zigZagTraversal(root);
for (int val : res) System.out.print(val + " ");
System.out.println();
}
}
# Python Program to traverse a binary
# tree in zigzag manner.
class Node:
def __init__(self, x):
self.data = x
self.left = None
self.right = None
# function to print the zigzag traversal
def zigZagTraversal(root):
res = []
if not root:
return res
dq = []
dq.append(root)
reverse = False
while dq:
n = len(dq)
while n > 0:
# Push right first if reverse is true
if reverse:
curr = dq.pop()
res.append(curr.data)
if curr.right:
dq.insert(0, curr.right)
if curr.left:
dq.insert(0, curr.left)
# Else push left first
else:
curr = dq.pop(0)
res.append(curr.data)
if curr.left:
dq.append(curr.left)
if curr.right:
dq.append(curr.right)
n -= 1
reverse = not reverse
return res
if __name__ == "__main__":
# Create a hard coded tree.
# 20
# / \
# 8 22
# / \ \
# 4 12 11
# / \
# 10 14
root = Node(20)
root.left = Node(8)
root.right = Node(22)
root.right.right = Node(11)
root.left.left = Node(4)
root.left.right = Node(12)
root.left.right.left = Node(10)
root.left.right.right = Node(14)
res = zigZagTraversal(root)
for val in res: print(val, end=" ")
print()
// C# Program to traverse a binary
// tree in zigzag manner.
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left;
public Node right;
public Node(int x) {
data = x;
left = null;
right = null;
}
}
class GfG {
// function to print the zigzag traversal
static List<int> zigZagTraversal(Node root) {
List<int> res = new List<int>();
if (root == null) return res;
LinkedList<Node> dq = new LinkedList<Node>();
dq.AddLast(root);
bool reverse = false;
while (dq.Count > 0) {
int n = dq.Count;
while (n-- > 0) {
// Push right first if reverse is true
if (reverse) {
Node curr = dq.Last.Value;
dq.RemoveLast();
res.Add(curr.data);
if (curr.right != null) dq.AddFirst(curr.right);
if (curr.left != null) dq.AddFirst(curr.left);
}
// Else push left first
else {
Node curr = dq.First.Value;
dq.RemoveFirst();
res.Add(curr.data);
if (curr.left != null) dq.AddLast(curr.left);
if (curr.right != null) dq.AddLast(curr.right);
}
}
reverse = !reverse;
}
return res;
}
static void Main() {
// Create a hard coded tree.
// 20
// / \
// 8 22
// / \ \
// 4 12 11
// / \
// 10 14
Node root = new Node(20);
root.left = new Node(8);
root.right = new Node(22);
root.right.right = new Node(11);
root.left.left = new Node(4);
root.left.right = new Node(12);
root.left.right.left = new Node(10);
root.left.right.right = new Node(14);
List<int> res = zigZagTraversal(root);
foreach (int val in res) Console.Write(val + " ");
Console.WriteLine();
}
}
// JavaScript Program to traverse a binary
// tree in zigzag manner.
class Node {
constructor(x) {
this.data = x;
this.left = null;
this.right = null;
}
}
// function to print the zigzag traversal
function zigZagTraversal(root) {
let res = [];
if (!root) return res;
let dq = [];
dq.push(root);
let reverse = false;
while (dq.length > 0) {
let n = dq.length;
while (n-- > 0) {
// Push right first if reverse is true
if (reverse) {
let curr = dq.pop();
res.push(curr.data);
if (curr.right) dq.unshift(curr.right);
if (curr.left) dq.unshift(curr.left);
}
// Else push left first
else {
let curr = dq.shift();
res.push(curr.data);
if (curr.left) dq.push(curr.left);
if (curr.right) dq.push(curr.right);
}
}
reverse = !reverse;
}
return res;
}
// Create a hard coded tree.
// 20
// / \
// 8 22
// / \ \
// 4 12 11
// / \
// 10 14
let root = new Node(20);
root.left = new Node(8);
root.right = new Node(22);
root.right.right = new Node(11);
root.left.left = new Node(4);
root.left.right = new Node(12);
root.left.right.left = new Node(10);
root.left.right.right = new Node(14);
let res = zigZagTraversal(root);
console.log(res.join(" "));
Output20 22 8 4 12 11 14 10