Inorder (Left, Root, Right) : 1 3 4 6 7 8 10 13 14

Preorder (Root, Left, Right) : 8 3 1 6 4 7 10 14 13

Postorder (Left, Right, Root) : 1 4 7 6 3 13 14 10 8

Inorder Traversal : In Inorder traversal a node is processed after processing of all nodes in its left subtree. The right subtree of the node is processed after processing the node itself.

Algorithm Inorder(tree)

1. Traverse the left subtree, i.e.,

call Inorder(left->subtree)

2. Visit the root.

3. Traverse the right subtree, i.e.,

call Inorder(right->subtree)

Preorder Traversal: In preorder traversal a node is processed before processing any of the nodes in its subtree.

Algorithm Preorder(tree)

1. Visit the root.

2. Traverse the left subtree, i.e.,

call Preorder(left-subtree)

3. Traverse the right subtree, i.e.,

call Preorder(right-subtree)

Postorder Traversal: In post order traversal, a node is processed after processing all of the nodes in its subtrees.

Algorithm Postorder(tree)

1. Traverse the left subtree, i.e.,

call Postorder(left-subtree)

2. Traverse the right subtree, i.e.,

call Postorder(right-subtree)

3. Visit the root.

c++:

```// C++ program for different tree traversals

#include <iostream>
using namespace std;

/* A binary tree node has data, pointer to left child
and a pointer to right child */
struct Node
{
int data;
struct Node* left, *right;
Node(int data)
{
this->data = data;
left = right = NULL;
}
};

// Function to print the postorder traversal
// of a Binary Tree
void printPostorder(struct Node* node)
{
if (node == NULL)
return;

// first recur on left subtree
printPostorder(node->left);

// then recur on right subtree
printPostorder(node->right);

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

// Function to print the Inorder traversal
// of a Binary Tree
void printInorder(struct Node* node)
{
if (node == NULL)
return;

/* first recur on left child */
printInorder(node->left);

/* then print the data of node */
cout << node->data << " ";

/* now recur on right child */
printInorder(node->right);
}

// Function to print the PreOrder traversal
// of a Binary Tree
void printPreorder(struct Node* node)
{
if (node == NULL)
return;

/* first print data of node */
cout << node->data << " ";

/* then recur on left sutree */
printPreorder(node->left);

/* now recur on right subtree */
printPreorder(node->right);
}

// Driver Code
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);

cout << "Preorder traversal of binary tree is \n";
printPreorder(root);

cout << "\nInorder traversal of binary tree is \n";
printInorder(root);

cout << "\nPostorder traversal of binary tree is \n";
printPostorder(root);

return 0;
}
```

java:
```// Java program for different tree traversals

/* Class containing left and right child of current
node and key value*/
class Node
{
int key;
Node left, right;

public Node(int item)
{
key = item;
left = right = null;
}
}

class BinaryTree
{
// Root of Binary Tree
Node root;

BinaryTree()
{
root = null;
}

// Method to print postorder traversal.
void printPostorder(Node node)
{
if (node == null)
return;

// first recur on left subtree
printPostorder(node.left);

// then recur on right subtree
printPostorder(node.right);

// now deal with the node
System.out.print(node.key + " ");
}

// Method to print inorder traversal
void printInorder(Node node)
{
if (node == null)
return;

/* first recur on left child */
printInorder(node.left);

/* then print the data of node */
System.out.print(node.key + " ");

/* now recur on right child */
printInorder(node.right);
}

// Method to print preorder traversal
void printPreorder(Node node)
{
if (node == null)
return;

/* first print data of node */
System.out.print(node.key + " ");

/* then recur on left sutree */
printPreorder(node.left);

/* now recur on right subtree */
printPreorder(node.right);
}

// Wrappers over above recursive functions
void printPostorder() {     printPostorder(root); }
void printInorder() {     printInorder(root); }
void printPreorder() {     printPreorder(root); }

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

System.out.println("Preorder traversal of binary tree is ");
tree.printPreorder();

System.out.println("\nInorder traversal of binary tree is ");
tree.printInorder();

System.out.println("\nPostorder traversal of binary tree is ");
tree.printPostorder();
}
}
```
output:
```Preorder traversal of binary tree is
1 2 4 5 3
Inorder traversal of binary tree is
4 2 5 1 3
Postorder traversal of binary tree is
4 5 2 3 1```

darkmode