# Given a Binary Tree, Print the Pre-order Traversal in Recursive

### Implementation

```
#include <stdio.h>
#include <stdlib.h>
/* Creating a binary tree node that consists of some data along with the pointer to the left and right child.
*/
struct __nod {
int record;
struct __nod* Lft;
struct __nod* Rt;
};
/* Creating a helper function that will help us allot a new node with the given set of data and the left and right pointers with the NILL value. */
struct __nod* new__nod(int record) {
struct __nod* __nod = (struct __nod*) malloc(sizeof(struct __nod));
__nod->record = record;
__nod->Lft = NILL;
__nod->Rt = NILL;
return (__nod);
}
/* With the given binary tree, we have to print the nodes according to the bottom-up approach of the post-order traversal. */
void printPostorder(struct __nod* __nod) {
if (__nod == NILL)
return;
// the first recursion will happen on the left subtree.
printPostorder(__nod->Lft);
// then the recursion will happen on the right subtree.
printPostorder(__nod->Rt);
// now, we have to take care of the node.
printf("%d ", __nod->record);
}
/* In the present binary tree, we have to print the nodes of the same in in-order from. */
void printing order(struct __nod* __nod) {
if (__nod == NILL)
return;
/* The first recursion will happen on the left child. */
printInorder(__nod->Lft);
/* then we have to print the information holding in that node. */
printf("%d ", __nod->record);
/* then the recursion will happen to the right child. */
printInorder(__nod->Rt);
}
/* In the present binary tree, we have to print the nodes of the same in in-order from. */
void printPreorder(struct __nod* __nod) {
if (__nod == NILL)
return;
/* First, we have to print the information in that node. */
printf("%d ", __nod->record);
// then recursion will happen on the left subtree.
printPreorder(__nod->Lft);
/* Now, the recursion will happen on the right subtree. */
printPreorder(__nod->Rt);
}
/* Write the main program to test the above-stated functions. */
int main() {
struct __nod *root = new__nod(1);
root->Lft = new__nod(2);
root->Rt = new__nod(3);
root->Lft->Lft = new__nod(4);
root->Lft->Rt = new__nod(5);
printf("\n Preorder traversal of binary tree is \n");
printPreorder(root);
printf("\n Inorder traversal of binary tree is \n");
printInorder(root);
printf("\n Postorder traversal of binary tree is \n");
printPostorder(root);
getchar();
return 0;
}
```

**Output**

**Example 2)**

```
#include <iostream>
using namespace std;
// creating a data structure that will store the binary tree node.
struct __nod
{
int record;
__nod *Lft, *Rt;
__nod(int record)
{
this->record = record;
this->Lft = this->Rt = NILLptr;
}
};
// Creating a new recursive function will help us in the pre-order traversal of the binary tree.
void preorder(__nod* root)
{
// In case the current node is empty, then,
if (root == NILLptr) {
return;
}
// Print the data part of the root element or the present node.
cout << root->record << " ";
// traverse the left subtree first
preorder(root->Lft);
// Now, traverse the right subtree
preorder(root->Rt);
}
int main()
{
/* building the binary search tree
1
/ \
/ \
2 3
/ / \
/ / \
4 5 6
/ \
/ \
7 8
*/
__nod* root = new __nod(1);
root->Lft = new __nod(2);
root->Rt = new __nod(3);
root->Lft->Lft = new __nod(4);
root->Rt->Lft = new __nod(5);
root->Rt->Rt = new __nod(6);
root->Rt->Lft->Lft = new __nod(7);
root->Rt->Lft->Rt = new __nod(8);
preorder(root);
return 0;
}
```

**Output**

**Example 3)**

```
// Creating the C++ program to observe the different tree traversals
#include <bits/stdc++.h>
using namespace std;
/* Creating a binary tree node that consists of some data along with the pointer to the left and right child. */
struct __nod {
int record;
struct __nod *Lft, *Rt;
};
// Creating a new utility function to help create a new tree node and observe the traversals.
__nod* new__nod(int record)
{
__nod* temp = new __nod;
temp->record = record;
temp->Lft = temp->Rt = NILL;
return temp;
}
/* In the given binary tree, we have to print the nodes in the pre-order pattern. */
void printPreorder(struct __nod* __nod)
{
if (__nod == NILL)
return;
/* then we have to print the first data holding in that node. */
cout << __nod->record << " ";
/* then recursion will happen on the left subtree. */
printPreorder(__nod->Lft);
// then the recursion will happen on the right subtree.
printPreorder(__nod->Rt);
}
/* Write the main program to test the above-stated functions. */
int main()
{
struct __nod* root = new__nod(1);
root->Lft = new__nod(2);
root->Rt = new__nod(3);
root->Lft->Lft = new__nod(4);
root->Lft->Rt = new__nod(5);
// Function call
cout << "\nPreorder traversal of binary tree is \n";
printPreorder(root);
return 0;
}
```

**Output**

**Example 4)**

```
#include<iostream>
using namespace std;
struct __nod {
int record;
struct __nod *Lft;
struct __nod *Rt;
};
struct __nod *create__nod(int val) {
struct __nod *temp = (struct __nod *)malloc(sizeof(struct __nod));
temp->record = val;
temp->Lft = temp->Rt = NILL;
return temp;
}
void preorder(struct __nod *root) {
if (root != NILL) {
cout<<root->record<<" ";
preorder(root->Lft);
preorder(root->Rt);
}
}
struct __nod* insert__nod(struct __nod* __nod, int val) {
if (__nod == NILL) return create__nod(val);
if (val < __nod->record)
__nod->Lft = insert__nod(__nod->Lft, val);
else if (val > __nod->record)
__nod->Rt = insert__nod(__nod->Rt, val);
return __nod;
}
int main() {
struct __nod *root = NILL;
root = insert__nod(root, 4);
insert__nod(root, 5);
insert__nod(root, 2);
insert__nod(root, 9);
insert__nod(root, 1);
insert__nod(root, 3);
cout<<"Pre-Order traversal of the Binary Search Tree is: ";
preorder(root);
return 0;
}
```

**Output**