# 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
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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++

 `// C++ program to print Vertical ` `// Zig-Zag traversal of tree ` `#include ` `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 > qu; ` ` `  `    ``// Push root node in the front of ` `    ``// the queue and mark as visited ` `    ``qu.push({ node, 0 }); ` `    ``nodes.push_back(node); ` `    ``vis[node] = ``true``; ` `    ``level = 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; ` `} `

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.