Vertical Zig-Zag traversal of a Tree

Given a Binary Tree, the task is to print the elements in the Vertical Zig-Zag traversal order.
Vertical Zig-Zag traversal of a tree is defined as:

  1. Print the elements of the first level in the order from right to left, if there are no elements left then skip to the next level.
  2. Print the elements of the last level in the order from left to right, if there are no elements left then skip to the previous level.
  3. Repeat the above steps while there are nodes left to traverse.

Examples:

Input: 
     1
  /     \
 2       3
  \     /  \
  4    5    6
  /          \
 7            8
Output: 1, 7, 3, 8, 2, 4, 6, 5
Explanation: 
1. First print elements of 1st level
   which will be printed as follows: 1

2. Now remaining part of the tree is 
    *
  /    \
 2       3
  \     /  \
  4    5     6
  /           \
7              8

3. Now move to 4th level print 
   from leftmost one element, 
   which will be: 7

4. Now tree becomes:
     *
  /     \
 2       3
  \     /  \
  4    5    6
  /          \
  *           8

5. Now move to since we move 
   from 2nd level since we move 
   from the lower level to higher-level 
   so start from rightmost, 
   so the element will be: 3

6. Now tree becomes:
     *
  /     \
 2       *
  \     /  \
  4    5    6
  /          \
 *            8

7. Now again move to 4th level 
   print from the leftmost remaining element, 
   which will be 8

8. Now tree becomes:
     *  
  /     \
 2       *
  \     /  \
  4    5    6
  /          \
 *            *

9. Now again move to 2nd level 
   print from the rightmost remaining element, 
   which will be 2 continue this way 
   until all elements are not traversed

Approach: Create a vector tree[] where tree[i] will store all the nodes of the tree at level i. Take two pointers p1 pointing to the first level and p2 pointing to the last level. Now, start printing the nodes in an alternate fashion using these two pointers (i.e. right to left for p1 and left to right for p2). If there are no nodes left in the level pointed by p1 then move to the next level and if there are no nodes left in the level pointed by p2 then move to the previous level.



Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to print Vertical
// Zig-Zag traversal of tree
#include <bits/stdc++.h>
using namespace std;
  
const int sz = 1e5;
int maxLevel = 0;
  
// Adjacency list representation
// of the tree
vector<int> tree[sz + 1];
  
// Boolean array to mark all the
// vertices which are visited
bool vis[sz + 1];
  
// Integer array to store the level
// of each node
int level[sz + 1];
  
// Array of vector where ith index
// stores all the nodes at level i
vector<int> nodes[sz + 1];
  
// Utility function to create an
// edge between two vertices
void addEdge(int a, int b)
{
  
    // Add a to b's list
    tree[a].push_back(b);
  
    // Add b to a's list
    tree[b].push_back(a);
}
  
// Modified Breadth-First Function
void bfs(int node)
{
  
    // Create a queue of {child, parent}
    queue<pair<int, int> > qu;
  
    // Push root node in the front of
    // the queue and mark as visited
    qu.push({ node, 0 });
    nodes[0].push_back(node);
    vis[node] = true;
    level[1] = 0;
  
    while (!qu.empty()) {
  
        pair<int, int> p = qu.front();
  
        // Dequeue a vertex from queue
        qu.pop();
        vis[p.first] = true;
  
        // Get all adjacent vertices of the dequeued
        // vertex s. If any adjacent has not
        // been visited then enqueue it
        for (int child : tree[p.first]) {
  
            if (!vis[child]) {
  
                qu.push({ child, p.first });
                level[child] = level[p.first] + 1;
                maxLevel = max(maxLevel, level[child]);
                nodes[level[child]].push_back(child);
            }
        }
    }
}
  
// Utility Function to display the pattern
void display()
{
    bool flag = true;
  
    // Pointers for the first and the last levels
    int p1 = 0, p2 = maxLevel;
  
    // i points to the last node of level
    // p1 and j points to the first
    // node of the level p2
    int i = nodes[p1].size() - 1, j = 0;
  
    // While there are nodes left to traverse
    while (p1 <= p2) {
  
        // Print the nodes in an alternate fashion
        if (flag) {
  
            // Print the last unvisited node
            // of the level p1
            cout << nodes[p1][i] << " ";
  
            // Move to the previous node
            i--;
  
            // If there are no nodes left then
            // move to the next level
            if (i < 0) {
                p1++;
                i = nodes[p1].size() - 1;
            }
        }
        else {
  
            // Print the first unvisited node
            // of the level p2
            cout << nodes[p2][j] << " ";
  
            // Move to the next node
            j++;
  
            // If there are no nodes left then
            // move to the previous level
            if (j >= nodes[p2].size()) {
                p2--;
                j = 0;
            }
        }
  
        // Change the flag
        flag = !flag;
  
        // If all the nodes have been traversed
        if (p1 >= p2 && i < j) {
            break;
        }
    }
}
  
// Driver code
int main()
{
  
    // Number of vertices
    int n = 8;
  
    addEdge(1, 2);
    addEdge(1, 3);
    addEdge(2, 4);
    addEdge(3, 5);
    addEdge(3, 6);
    addEdge(4, 7);
    addEdge(6, 8);
  
    // Calling modified bfs function
    bfs(1);
  
    display();
  
    return 0;
}

chevron_right


Output:

1 7 3 8 2 4 6 5

Time Complexity: O(n)

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.


Article Tags :
Practice Tags :


1


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.