Level Order Traversal in Spiral form

What is a binary tree?

A binary tree is a data structure that consists of nodes organized hierarchically. Each node has at most two children, typically the left and right child. The root node is the topmost node in the tree, and the leaf nodes are the nodes at the bottom of the tree with no children.

Here is a simple example of a binary tree:

This binary tree has seven nodes, with node 1 as the root node and nodes 4, 5, 6, and 7 as the leaf nodes.

Here is a pseudocode implementation of a binary tree:

// Define a Node class representing a binary tree node.
class Node {
  // Define properties for the node value left child and right child.
  public int value;
  public Node left;
  public Node right;

  // Define a constructor that initializes the node value and children.
  public Node(int value, Node left, Node right) {
    this.value = value;
    this.left = left;
    this.right = right;
  }
}

// Define a BinaryTree class that represents a binary tree.
class BinaryTree {
  // Define a property for the root node of the tree.
  public Node root;

  // Define a constructor that initializes the root node.
  public BinaryTree(Node root) {
    this.root = root;
  }
}

What is Level order traversal?

A level-order traversal of a binary tree involves visiting the nodes of the tree in a specific order. In a normal level order traversal, we visit the nodes of each level from left to right, starting from the root node and moving downward. In a normal level order traversal, we would visit the nodes in the following order: 1, 2, 3, 4, 5, 6, 7. This is called a level order traversal because we visit the nodes of each level of the tree before moving on to the next level.

To perform a level order traversal, we can use a queue to store the nodes at each level. We start by pushing the root node into the queue, and then we traverse the nodes at the current level from left to right. After all the nodes at the current level have been visited, we move on to the next level.

Level order traversal in spiral form is a type of tree traversal that visits each node in a tree in a spiral pattern. This type of traversal is useful for finding the shortest path between two nodes, as it allows the algorithm to explore all possible paths without backtracking. The spiral pattern of traversal is also useful for visualizing the structure of a tree, as it allows the user to see the relationships between nodes more clearly. The level order traversal in spiral form begins at the root node and then visits each node in a spiral pattern. The algorithm starts by visiting the root node, then moves clockwise around the tree, visiting each node in order. After visiting each node, the algorithm moves to the next level of the tree and repeats the process until all nodes have been visited. The level order traversal in spiral form is a recursive algorithm, meaning it calls itself repeatedly until all nodes have been visited.

What is Spiral form?

In a binary tree, the "spiral form" traverses the tree in which the nodes on each level are visited in a spiral pattern. This means that for each level of the tree, the nodes are visited from left to right, then from right to left, then from left to right, and so on.

Structure of binary tree in spiral form

Explanation

A level-order traversal of this tree in spiral form would visit the nodes in the following order: 1, 2, 3, 4, 5, 6, 7.

This is different from a regular level order traversal, which would visit the nodes in the order 1, 2, 3, 4, 5, 6, 7.

To perform a level order traversal of a binary tree in spiral form, you can use a queue and a stack. You would add the root node to the queue, then perform the following steps until the queue is empty:

Take the top element from the queue and add it to the result list.

If the node has a left child, add it to the queue.

If the node has the right child, add it to the stack.

If the queue is empty and the stack is not, pop all elements from the stack and add them to the queue.

This algorithm allows you to visit the nodes on each level in a spiral pattern, as described above.

Pseudocode

A level-order traversal of a binary tree involves visiting the tree's nodes in a specific order. In a normal level order traversal, we visit the nodes of each level from left to right. In a level order traversal in spiral form, we visit the nodes of each level in alternating directions (left to right, then right to left, and so on).

// Initialize the queue with the root node
queue.enqueue(root)
// Initialize the direction of traversal to left-to-right
direction = 1
// Loop until the queue is empty
while (the queue is not empty)
  // Calculate the number of nodes in the current level
  count = queue.size()

  // Traverse all the nodes in the current level
  for (i = 1 to count)
    // Dequeue a node from the queue
    node = queue.dequeue()

    // Print the node data
    print(node.data)

    // Enqueue the left and right children of the node, if they exist
    if (node.left) queue.enqueue(node.left)
    if (node.right) queue.enqueue(node.right)

  // Reverse the direction of traversal
  direction = -direction

C++ Code

// Here we are writing down the C++ programming language code to demonstrate
// the concept of Level order traversal in spiral form with its relevant 
// code and output supported by syntax 
#include <bits/stdc++.h>
using namespace std;
// defining the structure of the node from the below code
struct node {
	int data;
	// assigning the initial nodes to the left and right
	struct node* left;
           // structure node allocated dynamically to right
	struct node* right;
};
// below, we are writing down the void function to return us the value of the root node, level 
// structurally
void printGivenLevel(struct node* root, int level, int ltr);
// defining the height calling recursively with structure node as the parameter
int height(struct node* node);
// structure node dynamics
struct node* newNode(int data);
void printSpiral(struct node* root)
{
    // defining the height for the structure node
	int h = height(root);
	int i;
	bool ltr = false;
// running the for loop to print the level
	for (i = 1; i <= h; i++) {
		printGivenLevel(root, i, ltr);
		ltr = !ltr;
	}
}
// defining the void function to help us with defining the struct, and level from here
void printGivenLevel(struct node* root, int level, int ltr)
{
// conditional solving edge case if the root is null
	if (root == NULL)
		return;
// conditional solving if the level becomes one
	if (level == 1)
		cout << root->data << " ";
// edge case condition if level comes greater than one
	else if (level > 1) {
		if (ltr) {
			printGivenLevel(root->left, level - 1, ltr);
			printGivenLevel(root->right, level - 1, ltr);
		}
		else {
			printGivenLevel(root->right, level - 1, ltr);
			printGivenLevel(root->left, level - 1, ltr);
		}
	}
}
// defining the height function with a return type integer
int height(struct node* node)
{
	if (node == NULL)
		return 0;
// edge case condition if the level becomes greater than one
	else {
		int lheight = height(node->left);
		int rheight = height(node->right);
		if (lheight > rheight)
			return (lheight + 1);
		else
			return (rheight + 1);
	}
}
struct node* newNode(int data)
{
	node* newnode = new node();
	newnode->data = data;
	newnode->left = NULL;
	newnode->right = NULL;

	return (newnode);
}
// The main driver code functionality starts from here
int main()
{
	struct node* root = newNode(1);
	// defining the allocation of the root nodes
	root->left = newNode(2);
	root->right = newNode(3);
	root->left->left = newNode(7);
	root->left->right = newNode(6);
	root->right->left = newNode(5);
	root->right->right = newNode(4);
	// printing the spiral nodes traversal
	printf("Spiral Order traversal of "
		"binary tree is \n");

	printSpiral(root);

	return 0;
// The main driver code functionality ends from here	
    
}

Output:

Spiral Order traversal of binary tree is 
1 2 3 4 5 6 7

C Code

// Here we are writing down the C programming language code to demonstrate
// the concept of Level order traversal in spiral form with its relevant 
// code and output supported by syntax 
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
// defining the structure of the node from the below code
struct node {
	int data;
	// assigning the initial nodes to the left and right
	struct node* left;
	struct node* right;
};
void printGivenLevel(struct node* root, int level, int ltr);
int height(struct node* node);
// structure node dynamics
struct node* newNode(int data);
void printSpiral(struct node* root)
{
    
    // defining the height for the structure node
	int h = height(root);
	int i;
	bool ltr = false;
	// running the for loop to print the level
	for (i = 1; i <= h; i++) {
		printGivenLevel(root, i, ltr);
		ltr = !ltr;
	}
}
// defining the void function to help us with defining the struct, level
void printGivenLevel(struct node* root, int level, int ltr)
{
	if (root == NULL)
		return;
	if (level == 1)
		printf("%d ", root->data);
		// edge case condition if the level becomes greater than one
	else if (level > 1) {
		if (ltr) {
			printGivenLevel(root->left, level - 1, ltr);
			printGivenLevel(root->right, level - 1, ltr);
		}
		else {
			printGivenLevel(root->right, level - 1, ltr);
			printGivenLevel(root->left, level - 1, ltr);
		}
	}
}
// defining the height function with a return type integer
int height(struct node* node)
{
	if (node == NULL)
		return 0;
		// edge case condition if the level becomes greater than one
	else {
		int lheight = height(node->left);
		int rheight = height(node->right);
		if (lheight > rheight)
			return (lheight + 1);
		else
			return (rheight + 1);
	}
}
struct node* newNode(int data)
{
	struct node* node
		= (struct node*)malloc(sizeof(struct node));
	node->data = data;
	node->left = NULL;
	node->right = NULL;

	return (node);
}
// The main driver code functionality starts from here
int main()
{
	struct node* root = newNode(1);
	// defining the allocation of the root nodes
	root->left = newNode(2);
	root->right = newNode(3);
	root->left->left = newNode(7);
	root->left->right = newNode(6);
	root->right->left = newNode(5);
	root->right->right = newNode(4);
	// printing the spiral nodes traversal
	printf("Spiral Order traversal of binary tree is \n");
	printSpiral(root);

	return 0;
// The main driver code functionality ends from here
}

Output:

Spiral Order traversal of binary tree is 
1 2 3 4 5 6 7

The algorithm begins by visiting the root node, then moves clockwise around the tree, visiting each node in order. After visiting each node, the algorithm moves to the next level of the tree and repeats the process until all nodes have been visited. The level order traversal in spiral form is an efficient algorithm, as it visits each node in the tree only once. This makes it ideal for applications where the tree structure is large and complex, allowing the algorithm to explore all possible paths without backtracking.

C# algorithm

// Perform a level order traversal of the given binary tree in spiral form.
// Return a list containing the traversed nodes.
public List<int> SpiralLevelOrderTraversal(TreeNode root)
{
    // Initialize the result list and the queue and stack.
    List<int> result = new List<int>();
    Queue<TreeNode> queue = new Queue<TreeNode>();
    Stack<TreeNode> stack = new Stack<TreeNode>();

    // Add the root node to the queue.
    queue.Enqueue(root);

    // Perform the spiral traversal.
    while (queue.Count > 0 || stack.Count > 0)
    {
        // Take the top element from the queue and add it to the result list.
        TreeNode current = queue.Dequeue();
        result.Add(current.val);

        // If the node has a left child, add it to the queue.
        if (current.left != null)
        {
            queue.Enqueue(current.left);
        }

        // If the node has a right child, add it to the stack.
        if (current.right != null)
        {
            stack.Push(current.right);
        }

        // If the queue is empty and the stack is not, pop all elements from the stack
        // and add them to the queue.
        if (queue.Count == 0 && stack.Count > 0)
        {
            while (stack.Count > 0)
            {
                queue.Enqueue(stack.Pop());
            }
        }
    }

    // Return the result list.
    return result;
}

Explanation of Algorithm in C#

Note that this implementation assumes that you have a TreeNode class that represents a node in a binary tree, with val, left, and right properties that store the node's value, and references to its left and right child nodes, respectively. This pseudocode defines a Node class representing a node in a binary tree, with properties for the node value, left child, and right child. It also defines a BinaryTree class representing binary are, with a property for the tree's node.

To use this implementation, you can create a binary tree by creating a BinaryTree object and passing a Node object representing the root node to the constructor. Then, you can add nodes to the tree by setting the left and right properties of the parent node to reference the left and right child nodes.

Java code

// Define a node class to represent a node in the tree.
class Node {
	int data;
	Node left, right;

	public Node(int d)
	{
		data = d;
		left = right = null;
	}
}
// Define a class to represent the tree
class BinaryTree {
	Node root;

	// This method performs a level order traversal in spiral form.
    // It starts at the root node and prints the data in each node,
    // in spiral order.
	void printSpiral(Node node)
	{
		int h = height(node);
		int i;

		boolean ltr = false;
		for (i = 1; i <= h; i++) {
			printGivenLevel(node, i, ltr);

		
			ltr = !ltr;
		}
	}
// If the current level stack is empty, it means we have
            //I finished visiting all the nodes on the current level, so
            // we need to switch to the next level.
	
	int height(Node node)
	{
		if (node == null)
			return 0;
		else {

			
			int lheight = height(node.left);
			int rheight = height(node.right);

			
			if (lheight > rheight)
				return (lheight + 1);
			else
				return (rheight + 1);
		}
	}


	void printGivenLevel(Node node, int level, boolean ltr)
	{
	    // We will use two stacks to keep track of the nodes to visit.
        // One stack will hold the nodes on the current level, and the
        // other will hold the nodes on the next level.
		if (node == null)
			return;
		if (level == 1)
			System.out.print(node.data + " ");
		else if (level > 1) {
		     // Add the node's children to the next level stack in the
            // appropriate order depending on whether we are currently
            // traversing the current level from left to right or from
            // right to left.
			if (ltr != false) {
				printGivenLevel(node.left, level - 1, ltr);
				printGivenLevel(node.right, level - 1, ltr);
			}
			else {
				printGivenLevel(node.right, level - 1, ltr);
				printGivenLevel(node.left, level - 1, ltr);
			}
		}
	}
	
	public static void main(String[] args)
	{
		BinaryTree tree = new BinaryTree();
		tree.root = new Node(1);
		tree.root. left = new Node(2);
		tree.root.right = new Node(3);
		tree.root.left.left = new Node(7);
		tree.root.left.right = new Node(6);
		tree.root.right.left = new Node(5);
		tree.root.right.right = new Node(4);
		System.out.println(
			"Spiral order traversal of Binary Tree is ");
		tree.printSpiral(tree.root);
	}
}

Output:

The spiral order traversal of Binary Tree is 1 2 3 4 5 6 7

Additionally, the spiral pattern of traversal is useful for visualizing the structure of a tree, as it allows the user to see the relationships between nodes more clearly. In conclusion, level order traversal in spiral form is a type of tree traversal that visits each node in a tree in a spiral pattern. This type of traversal is useful for finding the shortest path between two nodes, as it allows the algorithm to explore all possible paths without backtracking. Additionally, the spiral pattern of traversal is useful for visualizing the structure of a tree, as it allows the user to see the relationships between nodes more clearly.

Java Script Code

function levelOrderSpiral(root) {
  if (!root) return;

  // Create an empty queue for level order traversal
  let queue = [];

  // Push the root node
  queue.push(root);

  // Track the direction of traversal. We start from left to right
  let direction = 1;

  // Run while the queue is not empty
  while (queue.length > 0) {
    // Calculate the number of nodes in current level
    let count = queue.length;

    // Traverse all nodes of current level
    for (let i = 0; i < count; i++) {
      // Dequeue a node from queue
      let node = queue.shift();

      // Print the node data
      console.log(node.data);

      // Enqueue left child
      if (node.left) queue.push(node.left);

      // Enqueue right child
      if (node.right) queue.push(node.right);
    }

    // Reverse the direction
    direction *= -1;
  }
}

Explanation

Here, we are using a queue to store the nodes at each level, and we use a variable direction to track the direction of traversal (left to right or right to left). At the end of each level, we reverse the direction. If this function is called with the root node of a binary tree, it will print the data of all the nodes in the tree in spiral-level order.

If the tree looks like the one below, then the output is

Output:

Level Order traversal in javascript

In a normal level order traversal, we would visit the nodes in the following order: 1, 2, 3, 4, 5, 6, 7.

In a level order traversal in spiral form, we would visit the nodes in the following order: 1, 3, 2, 4, 5, 6, 7.

To perform a level order traversal in spiral form, we can use a queue to store the nodes at each level. We start by pushing the root node into the queue, and then we traverse the nodes at the current level from left to right (or right to left, depending on the direction of traversal). After all the nodes at the current level have been visited, we reverse the direction of traversal and move on to the next level. This algorithm has a time complexity of O(n), where n is the number of nodes in the tree since we visit each node in the tree exactly once. It also has an O(n) space complexity since we use a queue to store the nodes at each level.

Python code

class newNode:
 # Define a Node class to represent a node in the tree.

	def __init__(self, key):
		self.data = key
		self.left = None
		self.right = None


 # This method performs a level order traversal in spiral form.
    # It starts at the root node and prints the data in each node,
    # in spiral order.


def printSpiral(root):
# Define a Tree class to represent the tree.
	h = height(root)


	ltr = False
	for i in range(1, h + 1):

		printGivenLevel(root, i, ltr)

		ltr = not ltr

# We will use two stacks to keep track of the nodes to visit.
        # One stack will hold the nodes on the current level, and the
        # other will hold the nodes on the next level.



def printGivenLevel(root, level, ltr):
    
    # Keep track of whether we are traversing the current level from
        # left to right or from right to left. Initially, we start from
        # left to right.

	if(root == None):
		return
	if(level == 1):
		print(root.data, end=" ")
	elif (level > 1):

		if(ltr):
			printGivenLevel(root.left, level - 1, ltr)
			printGivenLevel(root.right, level - 1, ltr)
# Add the node's children to the next level stack, in the
            # appropriate order depending on whether we are currently
            # traversing the current level from left to right or from
            # right to left.
		else:
			printGivenLevel(root.right, level - 1, ltr)
			printGivenLevel(root.left, level - 1, ltr)


 


def height(node):

	if (node == None):
		return 0
	else:

	
		lheight = height(node.left)
		rheight = height(node.right)

	 # If the current level stack is empty, it means we have
            # finished visiting all the nodes on the current level, so
            # we need to switch to the next level.	
		if (lheight > rheight):
			return(lheight + 1)
		else:
			return(rheight + 1)



if __name__ == '__main__':
	root = newNode(1)
	root.left = newNode(2)
	root.right = newNode(3)
	root.left.left = newNode(7)
	root.left.right = newNode(6)
	root.right.left = newNode(5)
	root.right.right = newNode(4)
	print("Spiral Order traversal of binary tree is")
	printSpiral(root)

Output:

Spiral order traversal of Binary Tree is 1 2 3 4 5 6 7

Explanation

A level-order traversal in spiral form is a way to traverse the nodes of a tree in level order but in a spiral pattern instead of a linear one. This means that the nodes on each level are visited in a circular pattern, starting from the left and going to the right, then going back to the right and going to the left, and so on. To perform a level order traversal in spiral form, we can use a similar approach to the one used for a normal level order traversal. We start at the root node and visit the nodes on the current level from left to right. Then, for each node on the current level, we add its children to a queue or stack (we will use a stack in this example) to keep track of the nodes on the next level.

After visiting all the nodes on the current level, we switch to the next level and visit its nodes in the opposite direction (from right to left instead of left to right). Then, for each node on this level, we add its children to the stack in the opposite order (right child first, then left child). We keep alternating between levels and directions in this way until we have visited all the nodes in the tree. This will result in a spiral pattern of traversal, where the nodes on each level are visited circularly.

Next TopicProblem with scanf() when there is fgets()/gets()/scanf() After it

← prev next →