Write a C program for Binary Tree Traversal to in-order, Pre-Order, And Post-Order.

Node:
  item
  left
  right

InorderTraversal(node):
  if node is null, return
  InorderTraversal(node.left)
  Print node.item
  InorderTraversal(node.right)

PreorderTraversal(node):
  if node is null, return
  Print node.item
  PreorderTraversal(node.left)
  PreorderTraversal(node.right)

PostorderTraversal(node):
  if node is null, return
  PostorderTraversal(node.left)
  PostorderTraversal(node.right)
  Print node.item

CreateNode(value):
  newNode = new Node
  newNode.item = value
  newNode.left = null
  newNode.right = null
  return newNode

InsertLeft(parent, value):
  parent.left = CreateNode(value)
  return parent.left

InsertRight(parent, value):
  parent.right = CreateNode(value)
  return parent.right

Main:
  root = CreateNode(1)
  leftNode = InsertLeft(root, 12)
  rightNode = InsertRight(root, 9)

  InsertLeft(leftNode, 5)
  InsertRight(leftNode, 6)

  Print "Inorder traversal:"
  InorderTraversal(root)

  Print "\nPreorder traversal:"
  PreorderTraversal(root)

  Print "\nPostorder traversal:"
  PostorderTraversal(root)

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

struct node {
  int item;
  struct node* left;
  struct node* right;
};

// Tree traversal functions
void inorderTraversal(struct node* root) {
  if (root == NULL) return;
  inorderTraversal(root->left);
  printf("%d -> ", root->item);
  inorderTraversal(root->right);
}

void preorderTraversal(struct node* root) {
  if (root == NULL) return;
  printf("%d -> ", root->item);
  preorderTraversal(root->left);
  preorderTraversal(root->right);
}

void postorderTraversal(struct node* root) {
  if (root == NULL) return;
  postorderTraversal(root->left);
  postorderTraversal(root->right);
  printf("%d -> ", root->item);
}

// Create a new Node
struct node* createNode(int value) {
  struct node* newNode = malloc(sizeof(struct node));
  newNode->item = value;
  newNode->left = NULL;
  newNode->right = NULL;
  return newNode;
}

// Insert a node on the left of the parent node
struct node* insertLeft(struct node* parent, int value) {
  parent->left = createNode(value);
  return parent->left;
}

// Insert a node on the right of the parent node
struct node* insertRight(struct node* parent, int value) {
  parent->right = createNode(value);
  return parent->right;
}

int main() {
  //!showMemory() 
  struct node* root = createNode(1);
  struct node* leftNode = insertLeft(root, 12);
  struct node* rightNode = insertRight(root, 9);

  insertLeft(leftNode, 5);
  insertRight(leftNode, 6);

  printf("Inorder traversal:\n");
  inorderTraversal(root);

  printf("\n\nPreorder traversal:\n");
  preorderTraversal(root);

  printf("\n\nPostorder traversal:\n");
  postorderTraversal(root);

  return 0;
}

Inorder traversal:
5 -> 12 -> 6 -> 1 -> 9 ->

Preorder traversal:
1 -> 12 -> 5 -> 6 -> 9 ->

Postorder traversal:
5 -> 6 -> 12 -> 9 -> 1 ->

Leave a comment

This site uses Akismet to reduce spam. Learn how your comment data is processed.