Inorder Traversal of Binary Tree

Last Updated : 28 Mar, 2025

Try it on GfG Practice

Inorder traversal is a depth-first traversal method that follows this sequence:

Left subtree is visited first.
Root node is processed next.
Right subtree is visited last.

How does Inorder Traversal work?

Key Properties:

If applied to a Binary Search Tree (BST), it returns elements in sorted order.
Ensures that nodes are processed in a hierarchical sequence, making it useful for expression trees and BSTs.

Examples

Input:

Output: 2 1 3
Explanation: The Inorder Traversal visits the nodes in the following order: Left, Root, Right. Therefore, we visit the left node 2, then the root node 1 and lastly the right node 3.
Input :

Output: 4 2 5 1 3 6
Explanation: Inorder Traversal (Left → Root → Right). Visit 4 → 2 → 5 → 1 → 3 → 6 , resulting in 4 2 5 1 3 6.

Algorithm :

If the root is NULL, return.
Recursively traverse the left subtree.
Process the root node (e.g., print its value).
Recursively traverse the right subtree.

C++

#include <bits/stdc++.h>
using namespace std;

// Structure of a Binary Tree Node
struct Node {
    int data;
    struct Node *left, *right;
    Node(int v)
    {
        data = v;
        left = right = nullptr;
    }
};

// Function to print inorder traversal
void printInorder(struct Node* node)
{
    if (node == nullptr)
        return;

    // First recur on left subtree
    printInorder(node->left);

    // Now deal with the node
    cout << node->data << " ";

    // Then recur on right subtree
    printInorder(node->right);
}

int main()
{
    struct Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->left->right = new Node(5);
    root->right->right = new Node(6);

    printInorder(root);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

// Structure of a Binary Tree Node
struct Node {
    int data;
    struct Node *left, *right;
};

// Function to print inorder traversal
void printInorder(struct Node* node) {
    if (node == NULL)
        return;

    // First recur on left subtree
    printInorder(node->left);

    // Now deal with the node
    printf("%d ", node->data);

    // Then recur on right subtree
    printInorder(node->right);
}

// Function to create a new node
struct Node* newNode(int v) {
    struct Node* node = 
      (struct Node*)malloc(sizeof(struct Node));
    node->data = v;
    node->left = node->right = NULL;
    return node;
}

int main() {
    struct Node* root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5);
    root->right->right = newNode(6);

    printInorder(root);

    return 0;
}

Java

import java.util.*;

// Structure of a Binary Tree Node
class Node {
    int data;
    Node left, right;

    Node(int v)
    {
        data = v;
        left = right = null;
    }
}

class GfG {
    // Function to print inorder traversal
    public static void printInorder(Node node)
    {
        if (node == null)
            return;

        // First recur on left subtree
        printInorder(node.left);

        // Now deal with the node
        System.out.print(node.data + " ");

        // Then recur on right subtree
        printInorder(node.right);
    }

    public static void main(String[] args)
    {
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.right = new Node(6);

        printInorder(root);
    }
}

Python

class Node:
    def __init__(self, v):
        self.data = v
        self.left = None
        self.right = None

# Function to print inorder traversal
def printInorder(node):
    if node is None:
        return

    # First recur on left subtree
    printInorder(node.left)

    # Now deal with the node
    print(node.data, end=' ')

    # Then recur on right subtree
    printInorder(node.right)

if __name__ == '__main__':
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)
    root.right.right = Node(6)

    printInorder(root)

using System;

// Structure of a Binary Tree Node
public class Node {
    public int data;
    public Node left, right;

    public Node(int v)
    {
        data = v;
        left = right = null;
    }
}

public class BinaryTree {
    // Function to print inorder traversal
    public static void printInorder(Node node)
    {
        if (node == null)
            return;

        // First recur on left subtree
        printInorder(node.left);

        // Now deal with the node
        Console.Write(node.data + " ");

        // Then recur on right subtree
        printInorder(node.right);
    }

    public static void Main()
    {
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.right = new Node(6);

        printInorder(root);
    }
}

JavaScript

// Structure of a Binary Tree Node
class Node {
    constructor(v) {
        this.data = v;
        this.left = null;
        this.right = null;
    }
}

// Function to print inorder traversal
function printInorder(node) {
    if (node === null) {
        return;
    }
    
    // First recur on left subtree
    printInorder(node.left);
    
    // Now deal with the node
    console.log(node.data);
    
    // Then recur on right subtree
    printInorder(node.right);
}


const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.right = new Node(6);

printInorder(root);

Output

4 2 5 1 3 6

Time Complexity: O(n), n is the total number of nodes
Auxiliary Space: O(h), h is the height of the tree.

In the worst case, h can be the same as N (when the tree is a skewed tree)
In the best case, h can be the same as log N (when the tree is a complete tree)

Related Articles: