# 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