Open In App

ZigZag Tree Traversal

Last Updated : 17 May, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

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.

ZigZag-Tree-Traversal

Table of Content

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:

  1. Initialize two stacks: s1 and s2, and push the root of the tree into s1.
  2. 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.
  3. 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 
// 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 
# 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# 
// 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 
// 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(" "));

Output
20 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:

  1. Initialize a deque dq and push the root of the binary tree into it.
  2. Set reverse = false, i.e., we will begin from the front of the deque.
  3. 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 
// 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 
# 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# 
// 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 
// 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(" "));

Output
20 22 8 4 12 11 14 10

ZigZag Tree Traversal | DSA Problem
Next Article
Analysis of Algorithms

S
Striver
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox