ZigZag Level Order Traversal of an N-ary Tree

Last Updated : 25 Oct, 2024

Given a Generic Tree consisting of n nodes, the task is to find the ZigZag Level Order Traversal of the given tree.
Note: A generic tree is a tree where each node can have zero or more children nodes. Unlike a binary tree, which has at most two children per node (left and right), a generic tree allows for multiple branches or children for each node.

Examples:

Input:

Output:
11
90 29 21
18 10 12 77

Approach:

The idea is to solve the given problem by using BFS Traversal. The approach is very similar to the Level Order Traversal of the N-ary Tree. It can be observed that on reversing the order of the even levels during the Level Order Traversal, the obtained sequence is a ZigZag traversal.

Below is the implementation of the above approach:

C++

// C++ implementation of Zigzag order
// traversal of an N-ary tree using BFS
#include <bits/stdc++.h>
using namespace std;

class Node {
public:
    int data;
    vector<Node*> children;
    
    Node(int val) {
        data = val;
    }
};

// Function to perform zigzag level
// order traversal
void zigzagTraversal(Node* root) {
  
    // Check if the tree is empty
    if (!root) return;

    queue<Node*> q;
 
    q.push(root);

    // Vector to store nodes of each level
    vector<vector<int>> result;

    while (!q.empty()) {
       
        int size = q.size();

        vector<int> curLevel;

        // Traverse all nodes in the current level
        for (int i = 0; i < size; i++) {

            Node* curr = q.front();
            q.pop();
            
            // Add the current node's value 
            // to the current level
            curLevel.push_back(curr->data);

            // Add all children of the current 
            // node to the queue
            for (auto child : curr->children) {
                q.push(child);
            }
        }

        // Store the current level in the result vector
        result.push_back(curLevel);
    }

    // Reverse the levels at even indices (0-based index)
    for (int i = 0; i < result.size(); i++) {
        
        // Reverse the level if it is at an odd index
        if (i % 2 != 0) {
            reverse(result[i].begin(), result[i].end());
        }
    }
  
    for (auto level : result) {
        for (int val : level) {
            cout << val << " ";
        }
        cout << endl;
    }
}

int main() {
    
     // Representation of given N-ary tree
    //         11
    //       /  |  \
    //     21   29  90
    //    /    /  \   \
    //   18   10  12  77
    Node* root = new Node(11);
    root->children.push_back(new Node(21));
    root->children.push_back(new Node(29));
    root->children.push_back(new Node(90));
    root->children[0]->children.push_back(new Node(18));
    root->children[1]->children.push_back(new Node(10));
    root->children[1]->children.push_back(new Node(12));
    root->children[2]->children.push_back(new Node(77));


    zigzagTraversal(root);

    return 0;
}

Java

// Java implementation of Zigzag order
// traversal of an N-ary tree using BFS
import java.util.*;

class Node {
    int data;
    List<Node> children;

    Node(int val) {
        data = val;
        children = new ArrayList<>();
    }
}

// Function to perform zigzag level order traversal
class GfG {

    static void zigzagTraversal(Node root) {

        // Check if the tree is empty
        if (root == null) return;

        Queue<Node> q = new LinkedList<>();

        q.add(root);

        // List to store nodes of each level
        List<List<Integer>> result = new ArrayList<>();

        while (!q.isEmpty()) {

            int size = q.size();

            List<Integer> curLevel = new ArrayList<>();

            // Traverse all nodes in the current level
            for (int i = 0; i < size; i++) {

                Node curr = q.poll();

                // Add the current node's value
                curLevel.add(curr.data);

                // Add all children of the current
                // node to the queue
                for (Node child : curr.children) {
                    q.add(child);
                }
            }

            // Store the current level in the
           	// result list
            result.add(curLevel);
        }

        // Reverse the levels at even indices
       //(0-based index)
        for (int i = 0; i < result.size(); i++) {

            // Reverse the level if it is at an
          	// odd index
            if (i % 2 != 0) {
                Collections.reverse(result.get(i));
            }
        }

        // Print the zigzag level order traversal
        for (List<Integer> level : result) {
            for (int val : level) {
                System.out.print(val + " ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {

        // Representation of given N-ary tree
        //         11
        //       /  |  \
        //     21   29  90
        //    /    /  \   \
        //   18   10  12  77
        Node root = new Node(11);
        root.children.add(new Node(21));
        root.children.add(new Node(29));
        root.children.add(new Node(90));
        root.children.get(0).children.add(new Node(18));
        root.children.get(1).children.add(new Node(10));
        root.children.get(1).children.add(new Node(12));
        root.children.get(2).children.add(new Node(77));

        zigzagTraversal(root);
    }
}

Python

# Python implementation of Zigzag order
# traversal of an N-ary tree using BFS
from collections import deque

class Node:
    def __init__(self, val):
        self.data = val
        self.children = []

# Function to perform zigzag level 
# order traversal
def zigzag_traversal(root):

    # Check if the tree is empty
    if not root:
        return

    q = deque()

    q.append(root)

    # List to store nodes of 
    # each level
    result = []

    while q:

        size = len(q)

        cur_level = []

        # Traverse all nodes in the current level
        for _ in range(size):

            curr = q.popleft()

            # Add the current node's value
            cur_level.append(curr.data)

            # Add all children of the current
            # node to the queue
            for child in curr.children:
                q.append(child)

        # Store the current level in the 
        # result list
        result.append(cur_level)

    # Reverse the levels at even indices 
    # (0-based index)
    for i in range(len(result)):

        # Reverse the level if it is at
        # an odd index
        if i % 2 != 0:
            result[i].reverse()

    # Print the zigzag level order traversal
    for level in result:
        print(" ".join(map(str, level)))
        
       
if __name__ == "__main__":
  
  # Representation of given N-ary tree
  #         11
  #       /  |  \
  #     21   29  90
  #    /    /  \   \
  #   18   10  12  77
  root = Node(11)
  root.children.append(Node(21))
  root.children.append(Node(29))
  root.children.append(Node(90))
  root.children[0].children.append(Node(18))
  root.children[1].children.append(Node(10))
  root.children[1].children.append(Node(12))
  root.children[2].children.append(Node(77))

  zigzag_traversal(root)

// C# implementation of Zigzag order
// traversal of an N-ary tree using BFS
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public List<Node> children;

    public Node(int val) {
        data = val;
        children = new List<Node>();
    }
}

class GfG {

    // Function to perform zigzag level 
  	// order traversal
    static void ZigzagTraversalFunc(Node root) {

        // Check if the tree is empty
        if (root == null) return;

        Queue<Node> q = new Queue<Node>();

        q.Enqueue(root);

        // List to store nodes of each level
        List<List<int>> result = new List<List<int>>();

        while (q.Count > 0) {

            int size = q.Count;

            List<int> curLevel = new List<int>();

            // Traverse all nodes in the current level
            for (int i = 0; i < size; i++) {

                Node curr = q.Dequeue();

                // Add the current node's value
                curLevel.Add(curr.data);

                // Add all children of the current
                // node to the queue
                foreach (Node child in curr.children) {
                    q.Enqueue(child);
                }
            }

            result.Add(curLevel);
        }

        // Reverse the levels at even indices
      	// (0-based index)
        for (int i = 0; i < result.Count; i++) {

            // Reverse the level if it is at
          	// an odd index
            if (i % 2 != 0) {
                result[i].Reverse();
            }
        }
      
        foreach (var level in result) {
            foreach (int val in level) {
                Console.Write(val + " ");
            }
            Console.WriteLine();
        }
    }

    static void Main(string[] args) {

       // Representation of given N-ary tree
        //         11
        //       /  |  \
        //     21   29  90
        //    /    /  \   \
        //   18   10  12  77
        Node root = new Node(11);
        root.children.Add(new Node(21));
        root.children.Add(new Node(29));
        root.children.Add(new Node(90));
        root.children[0].children.Add(new Node(18));
        root.children[1].children.Add(new Node(10));
        root.children[1].children.Add(new Node(12));
        root.children[2].children.Add(new Node(77));

        ZigzagTraversalFunc(root);
    }
}

JavaScript

// Javascript implementation of Zigzag order
// traversal of an N-ary tree using BFS
class Node {
    constructor(val) {
        this.data = val;
        this.children = [];
    }
}

// Function to perform zigzag level
// order traversal
function zigzagTraversal(root) {

    // Check if the tree is empty
    if (!root) return;

    const q = [];

    q.push(root);

    // Array to store nodes of 
    // each level
    const result = [];

    while (q.length > 0) {

        const size = q.length;

        const curLevel = [];

        // Traverse all nodes in the
        // current level
        for (let i = 0; i < size; i++) {

            const curr = q.shift();

            // Add the current node's value
            curLevel.push(curr.data);

            // Add all children of the current
            // node to the queue
            for (const child of curr.children) {
                q.push(child);
            }
        }
        
        result.push(curLevel);
    }

    // Reverse the levels at even indices
    // (0-based index)
    for (let i = 0; i < result.length; i++) {

        // Reverse the level if it is 
        // at an odd index
        if (i % 2 !== 0) {
            result[i].reverse();
        }
    }
    
    for (const level of result) {
        console.log(level.join(" "));
    }
}

// Representation of given N-ary tree
//         11
//       /  |  \
//     21   29  90
//    /    /  \   \
//   18   10  12  77
const root = new Node(11);
root.children.push(new Node(21));
root.children.push(new Node(29));
root.children.push(new Node(90));
root.children[0].children.push(new Node(18));
root.children[1].children.push(new Node(10));
root.children[1].children.push(new Node(12));
root.children[2].children.push(new Node(77));
zigzagTraversal(root);

Output

11 
90 29 21 
18 10 12 77

Time Complexity: O(n), where n is the number of nodes in the tree, as each node is processed once during the traversal.
Auxiliary Space: O(n), where n is the maximum number of nodes at any level in the tree, which is required for the queue and result storage.

Depth of an N-Ary tree

sohailahmed46khan786

Improve

Article Tags :

Practice Tags :

ZigZag Level Order Traversal of an N-ary Tree

Similar Reads

N-ary Tree Traversals

Easy problems on n-ary Tree

Thank You!

What kind of Experience do you want to share?