# What Is Pre Order Traversal in Data Structure?

//

Angela Bailey

What Is Pre Order Traversal in Data Structure?

In data structures, tree traversal is a crucial operation that involves visiting each node in a tree exactly once. Pre order traversal is one of the three common methods used to traverse a binary tree.

This method is widely used in various applications, including expression evaluation and creating prefix expressions.

## Understanding Pre Order Traversal

Pre order traversal follows a specific order when visiting the nodes of a binary tree. The general rule of pre order traversal is to visit the root node first, followed by recursively visiting the left subtree and then the right subtree.

### Steps Involved in Pre Order Traversal:

• Step 1: Visit the root node.
• Step 2: Traverse the left subtree using pre order traversal.
• Step 3: Traverse the right subtree using pre order traversal.

Let’s consider an example to understand how pre order traversal works. Suppose we have a binary tree with the following structure:

```        A
/ \
B   C
/ \   \
D   E   F
```

When performing pre order traversal on this tree, we would visit the nodes in the following sequence: A -> B -> D -> E -> C -> F.

Now let’s see how we can implement this algorithm using code.

## Implementing Pre Order Traversal Using Code

To implement pre order traversal in code, we can use recursion or an iterative approach. Here, we will focus on the recursive implementation.

First, let’s define a structure for our binary tree node:

```struct Node {
char data;
struct Node* left;
struct Node* right;
};
```

Now, let’s write the recursive function for pre order traversal:

```void preOrderTraversal(struct Node* root) {
if (root == NULL)
return;

printf("%c ", root->data);
preOrderTraversal(root->left);
preOrderTraversal(root->right);
}
```

In the above code, we check if the current node is NULL. If it is, we return. Otherwise, we print the data of the current node, then recursively call the function on the left and right subtrees.

To traverse our example tree using this function, we would call:

```struct Node* root = createNode('A');
root->left = createNode('B');
root->right = createNode('C');
root->left->left = createNode('D');
root->left->right = createNode('E');
root->right->right = createNode('F');

preOrderTraversal(root);
```

This will output: A B D E C F

By following these steps and implementing the pre order traversal algorithm in code, you can easily traverse and process binary trees in a pre order manner.

## Conclusion

In summary, pre order traversal is a common method used to traverse binary trees in data structures. By following a specific sequence of visiting nodes (root, left subtree, right subtree), you can effectively explore a tree’s structure and perform various operations on its elements.

Understanding and implementing this algorithm will greatly enhance your ability to work with binary trees.