Table of Contents

Tree Traversals (In Order, Pre Order, Post Order)

Tree Traversal (In Order, Pre Order, Post Order)

Traversing a tree is the process of visiting every node in the tree. Since all nodes are connected via edges, traversal is always started from the root node.
It is not possible to randomly access a node in a tree.

Basic structure of a tree

Every tree consists of :

  • A node carrying data or a value
  • Two subtrees
struct node 
{
    int data;
    struct node* left; // left child
    struct node* right; // right child
}

Note : The struct node pointed to by left and right might have other left and right children and should be considered as sub-trees instead of sub-nodes.

A hierarchical data structure like a tree can be traversed in three ways :

  • In-order Traversal
  • Pre-order Traversal
  • Post-order Traversal

In-order Traversal

Inorder Traversal basic

In inorder traversal, the output will produce sorted key values in ascending order.

Steps

Until all nodes are traversed :

  • Traverse left subtree.
  • Then the root node.
  • Traverse right subtree.

Note : Every node may represent a subtree itself.

In Order Traversal

Start from 3, then move to its left subtree 5. 5 is also traversed in-order.
The process goes on until all the nodes are visited.
The output of inorder traversal of this tree will be :

11 → 5 → 8 → 3 → 9 → 6 → 1

Code

void inorder(struct Node* node) 
{
  if (node != NULL)
   {
    inorder(node->left);
    print(node->data);
    inorder(node->right);
    }
}

Preorder Traversal

preorder traversal

Steps

  • Visit root node.
  • Traverse left subtree. (Visit all the nodes in the left subtree)
    • Traverse right subtree. (Visit all the nodes in the right subtree)

Note : Every node may represent a subtree itself.

Pre Order Traversal

Start from 3, then first visit 3 itself and then move to its left subtree 5. 5 is also traversed pre-order.
The process goes on until all the nodes are visited.
The output of pre-order traversal of this tree will be :

3→ 5 → 11 → 8 → 6 → 9 → 1

Code

void preorder(struct Node* node)
 {
  if (node != NULL)
  {
  print(node->data);
  preorder(node->left);
  preorder(node->right);
  }
}

Post-order Traversal

postorder traversal

Steps

Until all nodes are traversed :

  • Traverse left subtree.
  • Traverse right subtree.
  • Visit the root node.

Note : Every node may represent a subtree itself.

Post Order Traversal

Start from 3,then traverse the left subtree 5. 5 is also traversed post-order.
The process goes on until all the nodes are visited.
The output of post-order traversal of this tree will be :

11 → 8 → 5 → 9 → 1 → 6 → 3

Code


void postorder(struct Node* node)
 {
  if (node != NULL)
   {
     postorder(node->left);
     postorder(node->right);
     print(node->data);
   }
}

Implementation

This implementation is based on concepts used in Array Implementation Of Binary Trees

Scroll to Top