# Sideways traversal of a Complete Binary Tree

• Difficulty Level : Hard
• Last Updated : 07 Feb, 2022

Given a Complete Binary Tree, the task is to print the elements in the following pattern. Let’s consider the tree to be:

The tree is traversed in the following way:

The output for the above tree is:

1 3 7 11 10 9 8 4 5 6 2

Approach: The idea is to use the modified breadth first search function to store all the nodes at every level in an array of vector. Along with it, the maximum level up to which the tree needs to be traversed is also stored in a variable. After this precomputation task, the following steps are followed to get the required answer:

1. Create a vector tree[] where tree[i] will store all the nodes of the tree at the level i.
2. Take an integer variable k which keeps the track of the level number that is being traversed and another integer variable path which keeps the track of the number of cycles that have been completed. A flag variable is also created to keep the track of the direction in which the tree is being traversed.
3. Now, start printing the rightmost nodes at each level until the maximum level is reached.
4. Since the maximum level is reached, the direction has to be changed. In the last level, print elements from rightmost to left. And the value of maxLevel variable has to be decremented.
5. As the tree is being traversed from the lower level to the upper level, the rightmost elements are printed. Since in the next iteration, the maxlevel value has been changed, it makes sure that already visited nodes in the last level are not traversed again.

Below is the implementation of the above approach:

## C++

 // C++ program to print sideways // traversal of complete binary tree   #include using namespace std;   const int sz = 1e5; int maxLevel = 0;   // Adjacency list representation // of the tree vector 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 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[0].push_back(node);     vis[node] = true;     level[1] = 0;       while (!qu.empty()) {           pair 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() {     // k represents the level no.     // cycle represents how many     // cycles has been completed     int k = 0, path = 0;     int condn = (maxLevel) / 2 + 1;     bool flag = true;       // While there are nodes left to traverse     while (condn--) {           if (flag) {               // Traversing whole level from             // left to right             int j = nodes[k].size() - 1;             for (j = 0; j < nodes[k].size() - path; j++)                 cout << nodes[k][j] << " ";               // Moving to new level             k++;               // Traversing rightmost unvisited             // element  in path as we             // move up to down             while (k < maxLevel) {                   j = nodes[k].size() - 1;                 cout << nodes[k][j - path] << " ";                 k++;             }               j = nodes[k].size() - 1;             if (k > path)                 for (j -= path; j >= 0; j--)                     cout << nodes[k][j] << " ";               // Setting value of new maximum             // level upto which we have to traverse             // next time             maxLevel--;               // Updating from which level to             // start new path             k--;             path++;               flag = !flag;         }         else {               // Traversing each element of remaining             // last level from left to right             int j = nodes[k].size() - 1;             for (j = 0; j < nodes[k].size() - path; j++)                 cout << nodes[k][j] << " ";               // Decrementing value of Max level             maxLevel--;               k--;               // Traversing rightmost unvisited             // element  in path as we             // move down to up             while (k > path) {                   int j = nodes[k].size() - 1;                 cout << nodes[k][j - path] << " ";                 k--;             }               j = nodes[k].size() - 1;               if (k == path)                 for (j -= path; j >= 0; j--)                     cout << nodes[k][j] << " ";               path++;               // Updating the level number from which             // a new cycle has to be started             k++;             flag = !flag;         }     } }   // Driver code int main() {       // Initialising  the above mentioned     // complete binary tree     for (int i = 1; i <= 5; i++) {           // Adding edge to a binary tree         addEdge(i, 2 * i);         addEdge(i, 2 * i + 1);     }       // Calling modified bfs function     bfs(1);       display();       return 0; }

## Python3

 # Python3 program to print sideways # traversal of complete binary tree from collections import deque   sz = 10**5 maxLevel = 0   # Adjacency list representation # of the tree tree = [[] for i in range(sz + 1)]   # Boolean array to mark all the # vertices which are visited vis = [False]*(sz + 1)   # Integer array to store the level # of each node level = [0]*(sz + 1)   # Array of vector where ith index # stores all the nodes at level i nodes = [[] for i in range(sz + 1)]   # Utility function to create an # edge between two vertices def addEdge(a, b):       # Add a to b's list     tree[a].append(b)       # Add b to a's list     tree[b].append(a)   # Modified Breadth-First Function def bfs(node):     global maxLevel       # Create a queue of {child, parent}     qu = deque()       # Push root node in the front of     # the queue and mark as visited     qu.append([node, 0])     nodes[0].append(node)     vis[node] = True     level[1] = 0       while (len(qu) > 0):           p = qu.popleft()           # Dequeue a vertex from queue         vis[p[0]] = True           # Get all adjacent vertices of the dequeued         # vertex s. If any adjacent has not         # been visited then enqueue it         for child in tree[p[0]]:               if (vis[child] == False):                 qu.append([child, p[0]])                 level[child] = level[p[0]] + 1                 maxLevel = max(maxLevel, level[child])                 nodes[level[child]].append(child)   # Utility Function to display the pattern def display():     global maxLevel           # k represents the level no.     # cycle represents how many     # cycles has been completed     k = 0     path = 0     condn = (maxLevel) // 2 + 1     flag = True       # While there are nodes left to traverse     while (condn):           if (flag):               # Traversing whole level from             # left to right             j = len(nodes[k]) - 1             for j in range(len(nodes[k])- path):                 print(nodes[k][j],end=" ")               # Moving to new level             k += 1               # Traversing rightmost unvisited             # element in path as we             # move up to down             while (k < maxLevel):                   j = len(nodes[k]) - 1                 print(nodes[k][j - path], end=" ")                 k += 1               j = len(nodes[k]) - 1             if (k > path):                 while j >= 0:                     j -= path                     print(nodes[k][j], end=" ")                     j -= 1               # Setting value of new maximum             # level upto which we have to traverse             # next time             maxLevel -= 1               # Updating from which level to             # start new path             k -= 1             path += 1               flag = not flag         else:               # Traversing each element of remaining             # last level from left to right             j = len(nodes[k]) - 1             for j in range(len(nodes[k]) - path):                 print(nodes[k][j], end=" ")               # Decrementing value of Max level             maxLevel -= 1               k -= 1               # Traversing rightmost unvisited             # element in path as we             # move down to up             while (k > path):                   j = len(nodes[k]) - 1                 print(nodes[k][j - path], end=" ")                 k -= 1               j = len(nodes[k]) - 1               if (k == path):                 while j >= 0:                     j -= path                     print(nodes[k][j],end=" ")                     j -= 1               path += 1               # Updating the level number from which             # a new cycle has to be started             k += 1             flag = not flag         condn -= 1   # Driver code if __name__ == '__main__':       # Initialising the above mentioned     # complete binary tree     for i in range(1,6):           # Adding edge to a binary tree         addEdge(i, 2 * i)         addEdge(i, 2 * i + 1)       # Calling modified bfs function     bfs(1)       display()   # This code is contributed by mohit kumar 29

## Javascript



Output:

1 3 7 11 10 9 8 4 5 6 2

My Personal Notes arrow_drop_up
Related Articles