Inorder Traversal

In this article, we will discuss the inorder traversal in data structure.

If we want to traverse the nodes in ascending order, then we use the inorder traversal. Following are the steps required for the inorder traversal:

Visit all the nodes in the left subtree
Visit the root node
Visit all the nodes in the right subtree

Linear data structures such as stack, array, queue, etc., only have one way to traverse the data. But in hierarchical data structures such as tree, there are multiple ways to traverse the data. Here we will discuss another way to traverse the tree data structure, i.e., inorder traversal.

There are two approaches used for the inorder traversal:

Inorder traversal using Recursion
Inorder traversal using an Iterative method

An inorder traversal technique follows the Left Root Right policy. Here, Left Root Right means that the left subtree of the root node is traversed first, then the root node, and then the right subtree of the root node is traversed. Here, inorder name itself suggests that the root node comes in between the left and the right subtrees.

We will discuss the inorder traversal using both recursive and iterative techniques. Let's first start with inorder traversal using recursion.

Inorder traversal using recursion

Step 1: Recursively traverse the left subtree
Step 2: Now, visit the root
Step 3: Traverse the right subtree recursively

Example of inorder traversal

Now, let's see an example of inorder traversal. It will be easier to understand the procedure of inorder traversal using an example.

The nodes with yellow color are not visited yet. Now, we will traverse the nodes of the above tree using inorder traversal.

Here, 40 is the root node. We move to the left subtree of 40, that is 30, and it also has subtree 25, so we again move to the left subtree of 25 that is 15. Here, 15 has no subtree, so print 15 and move towards its parent node, 25.
Now, print 25 and move to the right subtree of 25.
Now, print 28 and move to the root node of 25 that is 30.
So, left subtree of 30 is visited. Now, print 30 and move to the right child of 30.
Now, print 35 and move to the root node of 30.
Now, print root node 40 and move to its right subtree.
Now recursively traverse the right subtree of 40 that is 50.
50 have subtree so first traverse the left subtree of 50 that is 45. 45 has no children, so print 45 and move to its root node.
Now print 50 and move to the right subtree of 50 that is 60.
Now recursively traverse the right subtree of 50 that is 60. 60 have subtree so first traverse the left subtree of 60 that is 55. 55 has no children, so print 55 and move to its root node.
Now print 60 and move to the right subtree of 60 that is 70.
Now print 70.

After the completion of inorder traversal, the final output is -

{15, 25, 28, 30, 35, 40, 45, 50, 55, 60, 70}

Complexity of Inorder traversal

The time complexity of Inorder traversal is O(n), where 'n' is the size of binary tree.

Whereas, the space complexity of inorder traversal is O(1), if we do not consider the stack size for function calls. Otherwise, the space complexity of inorder traversal is O(h), where 'h' is the height of tree.

Implementation of Inorder traversal

Now, let's see the implementation of inorder traversal in different programming languages.

Program: Write a program to implement inorder traversal in C language.

#include <stdio.h>
#include <stdlib.h>
struct node {
	int element;
	struct node* left;
	struct node* right;
};
/*To create a new node*/
struct node* createNode(int val)
{
	struct node* Node = (struct node*)malloc(sizeof(struct node));
	Node->element = val;
	Node->left = NULL;
	Node->right = NULL;
	return (Node);
}
/*function to traverse the nodes of binary tree in Inorder*/
void traverseInorder(struct node* root)
{
	if (root == NULL)
		return;
	traverseInorder(root->left);
	printf(" %d ", root->element);
	traverseInorder(root->right);
}
int main()
{
	struct node* root = createNode(40);
	root->left = createNode(30);
	root->right = createNode(50);
	root->left->left = createNode(25);
	root->left->right = createNode(35);
	root->left->left->left = createNode(15);
	root->left->left->right = createNode(28);
	root->right->left = createNode(45);
	root->right->right = createNode(60);
	root->right->right->left = createNode(55);
	root->right->right->right = createNode(70);	
	printf("\n The Inorder traversal of given binary tree is -\n");
	traverseInorder(root);
	return 0;
}

Output

Program: Write a program to implement inorder traversal in C++.

#include <iostream>
using namespace std;
struct node {
	int element;
	struct node* left;
	struct node* right;
};
/*To create a new node*/
struct node* createNode(int val)
{
	struct node* Node = (struct node*)malloc(sizeof(struct node));
	Node->element = val;
	Node->left = NULL;
	Node->right = NULL;
	return (Node);
}
/*function to traverse the nodes of binary tree in Inorder*/
void traverseInorder(struct node* root)
{
	if (root == NULL)
		return;
	traverseInorder(root->left);
	cout<<" "<<root->element<<" ";
	traverseInorder(root->right);
}
int main()
{
	struct node* root = createNode(39);
	root->left = createNode(29);
	root->right = createNode(49);
	root->left->left = createNode(24);
	root->left->right = createNode(34);
	root->left->left->left = createNode(14);
	root->left->left->right = createNode(27);
	root->right->left = createNode(44);
	root->right->right = createNode(59);
	root->right->right->left = createNode(54);
	root->right->right->right = createNode(69);	
	cout<<"\n The Inorder traversal of given binary tree is -\n";
	traverseInorder(root);
	return 0;
}

Output

Program: Write a program to implement inorder traversal in C#.

using System;
class Node {
	public int value;
	public Node left, right;
	public Node(int element)
	{
		value = element;
		left = right = null;
	}
}
class BinaryTree {
	Node root;
	BinaryTree() { root = null; }
	void traverseInorder(Node node)
	{
		if (node == null)
			return;
		traverseInorder(node.left);
		Console.Write(node.value + " ");
		traverseInorder(node.right);
	}
	void traverseInorder() { traverseInorder(root); }
	static void Main()
	{
		BinaryTree bt = new BinaryTree();
		bt.root = new Node(36);
		bt.root.left = new Node(26);
		bt.root.right = new Node(46);
		bt.root.left.left = new Node(21);
		bt.root.left.right = new Node(31);
		bt.root.left.left.left = new Node(11);
		bt.root.left.left.right = new Node(24);
		bt.root.right.left = new Node(41);
		bt.root.right.right = new Node(56);
		bt.root.right.right.left = new Node(51);
		bt.root.right.right.right = new Node(66);
		Console.WriteLine("The Inorder traversal of given binary tree is - ");
		bt.traverseInorder();
	}
}

Output

Program: Write a program to implement inorder traversal in Java.

class Node {
	public int value;
	public Node left, right;
	public Node(int element)
	{
		value = element;
		left = right = null;
	}
}
class InorderTraversal {
	Node root;
	InorderTraversal() { root = null; }
	void traverseInorder(Node node)
	{
		if (node == null)
			return;
		traverseInorder(node.left);
		System.out.print(node.value + " ");
		traverseInorder(node.right);
	}
	void traverseInorder() { traverseInorder(root); }
	public static void main(String args[])
	{
		InorderTraversal pt = new InorderTraversal();
		pt.root = new Node(35);
		pt.root.left = new Node(25);
		pt.root.right = new Node(45);
		pt.root.left.left = new Node(20);
		pt.root.left.right = new Node(30);
		pt.root.left.left.left = new Node(10);
		pt.root.left.left.right = new Node(23);
		pt.root.right.left = new Node(40);
		pt.root.right.right = new Node(55);
		pt.root.right.right.left = new Node(50);
		pt.root.right.right.right = new Node(66);
		System.out.println();
		System.out.println("The Inorder traversal of given 
binary tree is - ");
		pt.traverseInorder();
		System.out.println();
	}
}

Output