Preorder vs Inorder vs Postorder

Last Updated : 17 Apr, 2024

In Preorder Traversal, the root node is visited first, followed by the left and right subtrees. Inorder Traversal starts with the left subtree, visits the root, and then the right subtree, often used in binary search trees. Postorder Traversal begins with the left subtree, moves to the right subtree, and visits the root last, useful for deleting nodes. In this article, we will discuss the Tree Traversal Techniques used in data structure and algorithms with their differences.

Preorder Traversal

Preorder traversal is defined as a type of tree traversal that follows the Root-Left-Right policy where:

The root node of the subtree is visited first.
Then the left subtree is traversed.
At last, the right subtree is traversed.

In-order Traversal

Inorder traversal is defined as a type of tree traversal technique that follows the Left-Root-Right pattern, such that:

The left subtree is traversed first.
Then the root node for that subtree is traversed.
Finally, the right subtree is traversed.

Postorder Traversal

Postorder traversal is defined as a type of tree traversal that follows the Left-Right-Root policy such that for each node:

The left subtree is traversed first.
Then the right subtree is traversed.
Finally, the root node of the subtree is traversed.

Below is the Implementation of the above idea:

C++

#include <iostream>
using namespace std;

// Definition of a binary tree node
class TreeNode {
public:
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int val) : val(val), left(nullptr), right(nullptr) {}
};

// Pre-order traversal
void preorderTraversal(TreeNode* root) {
    if (root) {
        cout << root->val << " "; // Visit root
        preorderTraversal(root->left); // Recursively traverse left subtree
        preorderTraversal(root->right); // Recursively traverse right subtree
    }
}

// In-order traversal
void inorderTraversal(TreeNode* root) {
    if (root) {
        inorderTraversal(root->left); // Recursively traverse left subtree
        cout << root->val << " "; // Visit root
        inorderTraversal(root->right); // Recursively traverse right subtree
    }
}

// Post-order traversal
void postorderTraversal(TreeNode* root) {
    if (root) {
        postorderTraversal(root->left); // Recursively traverse left subtree
        postorderTraversal(root->right); // Recursively traverse right subtree
        cout << root->val << " "; // Visit root
    }
}

// Example tree
int main() {
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);
    root->right->right = new TreeNode(6);

    // Pre-order traversal
    cout << "Pre-order traversal: ";
    preorderTraversal(root);
    cout << endl;

    // In-order traversal
    cout << "In-order traversal: ";
    inorderTraversal(root);
    cout << endl;

    // Post-order traversal
    cout << "Post-order traversal: ";
    postorderTraversal(root);
    cout << endl;

    return 0;
}

Java

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int val) {
        this.val = val;
    }
}

public class Main {
    // Pre-order traversal
    public static void preorderTraversal(TreeNode root) {
        if (root != null) {
            System.out.print(root.val + " "); // Visit root
            preorderTraversal(root.left); // Recursively traverse left subtree
            preorderTraversal(root.right); // Recursively traverse right subtree
        }
    }

    // In-order traversal
    public static void inorderTraversal(TreeNode root) {
        if (root != null) {
            inorderTraversal(root.left); // Recursively traverse left subtree
            System.out.print(root.val + " "); // Visit root
            inorderTraversal(root.right); // Recursively traverse right subtree
        }
    }

    // Post-order traversal
    public static void postorderTraversal(TreeNode root) {
        if (root != null) {
            postorderTraversal(root.left); // Recursively traverse left subtree
            postorderTraversal(root.right); // Recursively traverse right subtree
            System.out.print(root.val + " "); // Visit root
        }
    }

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

        // Pre-order traversal
        System.out.print("Pre-order traversal: ");
        preorderTraversal(root);
        System.out.println();

        // In-order traversal
        System.out.print("In-order traversal: ");
        inorderTraversal(root);
        System.out.println();

        // Post-order traversal
        System.out.print("Post-order traversal: ");
        postorderTraversal(root);
        System.out.println();
    }
}

Python3

# Definition of a binary tree node
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

# Pre-order traversal
def preorder_traversal(root):
    if root:
        print(root.val, end=" ")  # Visit root
        preorder_traversal(root.left)  # Recursively traverse left subtree
        preorder_traversal(root.right)  # Recursively traverse right subtree

# In-order traversal
def inorder_traversal(root):
    if root:
        inorder_traversal(root.left)  # Recursively traverse left subtree
        print(root.val, end=" ")  # Visit root
        inorder_traversal(root.right)  # Recursively traverse right subtree

# Post-order traversal
def postorder_traversal(root):
    if root:
        postorder_traversal(root.left)  # Recursively traverse left subtree
        postorder_traversal(root.right)  # Recursively traverse right subtree
        print(root.val, end=" ")  # Visit root

# Example tree
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.right = TreeNode(6)

# Pre-order traversal
print("Pre-order traversal:")
preorder_traversal(root)
print()

# In-order traversal
print("In-order traversal:")
inorder_traversal(root)
print()

# Post-order traversal
print("Post-order traversal:")
postorder_traversal(root)
print()

using System;

// Definition of a binary tree node
public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int val) {
        this.val = val;
    }
}

public class BinaryTreeTraversal {
    // Pre-order traversal
    public static void PreorderTraversal(TreeNode root) {
        if (root != null) {
            Console.Write(root.val + " "); // Visit root
            PreorderTraversal(root.left); // Recursively traverse left subtree
            PreorderTraversal(root.right); // Recursively traverse right subtree
        }
    }

    // In-order traversal
    public static void InorderTraversal(TreeNode root) {
        if (root != null) {
            InorderTraversal(root.left); // Recursively traverse left subtree
            Console.Write(root.val + " "); // Visit root
            InorderTraversal(root.right); // Recursively traverse right subtree
        }
    }

    // Post-order traversal
    public static void PostorderTraversal(TreeNode root) {
        if (root != null) {
            PostorderTraversal(root.left); // Recursively traverse left subtree
            PostorderTraversal(root.right); // Recursively traverse right subtree
            Console.Write(root.val + " "); // Visit root
        }
    }

    // Example tree
    public static void Main(string[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        root.right.right = new TreeNode(6);

        // Pre-order traversal
        Console.Write("Pre-order traversal: ");
        PreorderTraversal(root);
        Console.WriteLine();

        // In-order traversal
        Console.Write("In-order traversal: ");
        InorderTraversal(root);
        Console.WriteLine();

        // Post-order traversal
        Console.Write("Post-order traversal: ");
        PostorderTraversal(root);
        Console.WriteLine();
    }
}

JavaScript

// Definition of a binary tree node
class TreeNode {
    constructor(val) {
        this.val = val;
        this.left = null;
        this.right = null;
    }
}

// Pre-order traversal
function preorderTraversal(root) {
    if (root) {
        console.log(root.val); // Visit root
        preorderTraversal(root.left); // Recursively traverse left subtree
        preorderTraversal(root.right); // Recursively traverse right subtree
    }
}

// In-order traversal
function inorderTraversal(root) {
    if (root) {
        inorderTraversal(root.left); // Recursively traverse left subtree
        console.log(root.val); // Visit root
        inorderTraversal(root.right); // Recursively traverse right subtree
    }
}

// Post-order traversal
function postorderTraversal(root) {
    if (root) {
        postorderTraversal(root.left); // Recursively traverse left subtree
        postorderTraversal(root.right); // Recursively traverse right subtree
        console.log(root.val); // Visit root
    }
}

// Example tree
let root = new TreeNode(1);
root.left = new TreeNode(2);
root.right = new TreeNode(3);
root.left.left = new TreeNode(4);
root.left.right = new TreeNode(5);
root.right.right = new TreeNode(6);

// Pre-order traversal
console.log("Pre-order traversal:");
preorderTraversal(root);

// In-order traversal
console.log("In-order traversal:");
inorderTraversal(root);

// Post-order traversal
console.log("Post-order traversal:");
postorderTraversal(root);

Output

Pre-order traversal: 1 2 4 5 3 6 
In-order traversal: 4 2 5 1 3 6 
Post-order traversal: 4 5 2 6 3 1

Preorder vs Inorder vs Postorder:

Attribute	Pre-order	In-order	Post-order
Visit Order	Root, Left Subtree, Right Subtree	Left Subtree, Root, Right Subtree	Left Subtree, Right Subtree, Root
Sorted Order (BST)	No	Yes	Yes
Expression Tree	Prefix (Polish) Notation	Infix (Standard) Notation	Postfix (Reverse Polish) Notation
Evaluation Order	Operators come before operands	Operators come between operands	Operators come after operands
Memory Usage	No additional memory for tracking traversal, stack space for recursion/iteration	No additional memory for tracking traversal, stack space for recursion/iteration	No additional memory for tracking traversal, stack space for recursion/iteration
Left-Right Symmetry	Not symmetric	Symmetric	Not symmetric
Application	Constructing expression trees, cloning/copying trees, prefix notation	In-order traversal of BST for sorted order, expression evaluation	Deleting nodes in binary trees, post-fix notation, expression evaluation
Performance	Better for copying/cloning trees, prefix notation	Suitable for sorting BST elements, expression evaluation	Suitable for deleting nodes, post-fix notation, expression evaluation
Tree Modification	Easy to copy/cloning, preserving original structure	Not ideal for modification	Difficult for modification, requires reversing