Level order traversal in spiral form using stack and multimap
Given a binary tree of N nodes, the task is to print level order traversal in a spiral form. In spiral form, nodes at the first and second level of tree are printed normally (left to right), after which nodes at alternate levels are printed in reverse order. Examples:
Input: N = 3
1
/ \
3 2
Output: 1 3 2 Explanation: Nodes at level 0 printed in normal order (1) Nodes at level 1 printed in normal order (3, 2) Hence, spiral order is (1, 3, 2) Input: N = 5
10
/ \
20 30
/ \
40 60
Output: 10 20 30 60 40 Explanation: Nodes at level 0 printed in normal order (10) Nodes at level 1 printed in normal order (20, 30) Nodes at level 2 printed in reverse order (60, 40) Hence, spiral order is (10, 20, 30, 60, 40)
Naive Approach: A naive approach for this problem has already been discussed in this article. The basic idea is to use recursion and a flag variable, using which nodes of alternate levels are printed in reverse order and finally spiral form is obtained. Time complexity: O(N2) Auxiliary Space: O(1) Efficient Approach: In this approach, stack and multimap are used. A multimap container in C++ stores the (key, value) pairs in ascending order, sorted according to the key. For every node of a given tree, if we put (level, node) in a multimap, then it will store these nodes sorted according to their level. For example, a given tree is: For this tree, the multimap would look like:
Key(Level) Value(Element)
0 1
1 2
1 3
2 7
2 6
2 5
2 4
Detailed steps of this approach are as follows:
- Traverse the given tree and insert all (level, node) pairs in a multimap and then traverse this multimap.
- If the level is odd, print the nodes in order in which they are present in the multimap.
- If the level is even, push all elements of the current level to a stack then pop all elements from the stack and print them. It gives the reverse order.
Finally, this level order traversal will result in the required spiral form. Below is the implementation of the above approach:
CPP
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node* left;
Node* right;
};
Node* newNode( int val)
{
Node* temp = new Node;
temp->data = val;
temp->left = NULL;
temp->right = NULL;
return temp;
}
void printSpiral(Node* root);
Node* buildTree(string str)
{
if (str.length() == 0
|| str[0] == 'N' )
return NULL;
vector<string> ip;
istringstream iss(str);
for (string str; iss >> str;)
ip.push_back(str);
Node* root = newNode(stoi(ip[0]));
queue<Node*> queue;
queue.push(root);
int i = 1;
while (!queue.empty()
&& i < ip.size()) {
Node* currNode = queue.front();
queue.pop();
string currVal = ip[i];
if (currVal != "N" ) {
currNode->left = newNode(stoi(currVal));
queue.push(currNode->left);
}
i++;
if (i >= ip.size())
break ;
currVal = ip[i];
if (currVal != "N" ) {
currNode->right = newNode(stoi(currVal));
queue.push(currNode->right);
}
i++;
}
return root;
}
multimap< int , int > m;
void fillMultiMap(Node* root, int level)
{
if (root == NULL)
return ;
else {
m.insert(pair< int , int >(
level, root->data));
fillMultiMap(
root->left, level + 1);
fillMultiMap(
root->right, level + 1);
}
}
void printSpiral(Node* root)
{
m.clear();
fillMultiMap(root, 0);
stack< int > s;
map< int , int >::iterator it
= m.begin();
while (it != m.end()) {
if ((it->first) % 2 != 0) {
while (!s.empty()) {
cout << s.top() << " " ;
s.pop();
}
cout << it->second << " " ;
}
else {
s.push(it->second);
}
it++;
}
while (!s.empty()) {
cout << s.top() << " " ;
s.pop();
}
return ;
}
int main()
{
string s = "1 2 3 7 6 5 4" ;
Node* root = buildTree(s);
printSpiral(root);
return 0;
}
|
Python3
from typing import List
import queue
import collections
class Node:
def __init__( self , val: int = 0 , left: 'Node' = None , right: 'Node' = None ):
self .data = val
self .left = left
self .right = right
def print_spiral(root: Node) - > None :
m = collections.defaultdict( list )
def fill_multimap(root: Node, level: int ) - > None :
if root is None :
return
m[level].append(root.data)
fill_multimap(root.left, level + 1 )
fill_multimap(root.right, level + 1 )
fill_multimap(root, 0 )
for level, level_nodes in m.items():
if level % 2 = = 0 :
level_nodes.reverse()
print ( " " .join( str (x) for x in level_nodes), end = " " )
return
def build_tree(nodes: List [ str ]) - > Node:
n = len (nodes)
if n = = 0 or nodes[ 0 ] = = 'N' :
return None
root = Node( int (nodes[ 0 ]))
q = queue.Queue()
q.put(root)
i = 1
while not q.empty() and i < n:
curr_node = q.get()
if nodes[i] ! = 'N' :
curr_node.left = Node( int (nodes[i]))
q.put(curr_node.left)
i + = 1
if i > = n:
break
if nodes[i] ! = 'N' :
curr_node.right = Node( int (nodes[i]))
q.put(curr_node.right)
i + = 1
return root
if __name__ = = '__main__' :
s = "1 2 3 7 6 5 4" .split()
root = build_tree(s)
print_spiral(root)
|
Time complexity: O(NlogN) Auxiliary Space: O(N)
Last Updated :
26 Apr, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...