Preorder Traversal

In this article, we will discuss the preorder traversal in data structure. Linear data structures such as stack, array, queue, etc., only have one way to traverse the data. But in a hierarchical data structure such as tree, there are multiple ways to traverse the data.

In preorder traversal, first, root node is visited, then left sub-tree and after that right sub-tree is visited. The process of preorder traversal can be represented as -

Root node is always traversed first in preorder traversal, while it is the last item of postorder traversal. Preorder traversal is used to get the prefix expression of a tree.

The steps to perform the preorder traversal are listed as follows -

First, visit the root node.
Then, visit the left subtree.
At last, visit the right subtree.

The preorder traversal technique follows the Root Left Right policy. The name preorder itself suggests that the root node would be traversed first.

Algorithm

Now, let's see the algorithm of preorder traversal.

Step 1: Repeat Steps 2 to 4 while TREE != NULL
Step 2: Write TREE -> DATA
Step 3: PREORDER(TREE -> LEFT)
Step 4: PREORDER(TREE -> RIGHT)
[END OF LOOP]
Step 5: END

Example of preorder traversal

Now, let's see an example of preorder traversal. It will be easier to understand the process of preorder traversal using an example.

The nodes with yellow color are not visited yet. Now, we will traverse the nodes of the above tree using preorder traversal.

Start with the root node 40. First, print 40 and then recursively traverse the left subtree.
Now, move to the left subtree. For left subtree, the root node is 30. Print 30, and move towards the left subtree of 30.
In left subtree of 30, there is an element 25, so print 25, and traverse the left subtree of 25.
In left subtree of 25, there is an element 15, and 15 has no subtree. So, print 15, and move to the right subtree of 25.
In right subtree of 25, there is 28, and 28 has no subtree. So, print 28, and move to the right subtree of 30.
In right subtree of 30, there is 35 that has no subtree. So print 35, and traverse the right subtree of 40.
In the right subtree of 40, there is 50. Print 50, and traverse the left subtree of 50.
In the left subtree of 50, there is 45 that do not have any child. So, print 45, and traverse the right subtree of 50.
In right subtree of 50, there is 60. Print 60 and traverse the left subtree of 60.
In the left subtree of 60, there is 55 that does not have any child. So, print 55 and move to the right subtree of 60.
In the right subtree of 60, there is 70 that do not have any child. So, print 70 and stop the process.

After the completion of preorder traversal, the final output is -

40, 30, 25, 15, 28, 35, 50, 45, 60, 55, 70

Complexity of Preorder traversal

The time complexity of preorder traversal is O(n), where 'n' is the size of binary tree.

Whereas, the space complexity of preorder traversal is O(1), if we do not consider the stack size for function calls. Otherwise, the space complexity of preorder traversal is O(h), where 'h' is the height of the tree.

Implementation of Preorder traversal

Now, let's see the implementation of preorder traversal in different programming languages.

Program: Write a program to implement preorder traversal in C language.

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

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

/*To create a new node*/
struct node* createNode(int val)
{
	struct node* Node = (struct node*)malloc(sizeof(struct node));
	Node->element = val;
	Node->left = NULL;
	Node->right = NULL;

	return (Node);
}


/*function to traverse the nodes of binary tree in preorder*/
void traversePreorder(struct node* root)
{
	if (root == NULL)
		return;
	printf(" %d ", root->element);
	traversePreorder(root->left);
	traversePreorder(root->right);
}

int main()
{
	struct node* root = createNode(40);
	root->left = createNode(30);
	root->right = createNode(50);
	root->left->left = createNode(25);
	root->left->right = createNode(35);
	root->left->left->left = createNode(15);
	root->left->left->right = createNode(28);
	root->right->left = createNode(45);
	root->right->right = createNode(60);
	root->right->right->left = createNode(55);
	root->right->right->right = createNode(70);
	
	printf("\n The Preorder traversal of given binary tree is -\n");
	traversePreorder(root);
	return 0;
}

Output

After the execution of the above code, the output will be -

Program: Write a program to implement preorder traversal in C++.

#include <iostream>

using namespace std;

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

/*To create a new node*/
struct node* createNode(int val)
{
	struct node* Node = (struct node*)malloc(sizeof(struct node));
	Node->element = val;
	Node->left = NULL;
	Node->right = NULL;

	return (Node);
}


/*function to traverse the nodes of binary tree in preorder*/
void traversePreorder(struct node* root)
{
	if (root == NULL)
		return;
	cout<<" "<<root->element<<" ";
	traversePreorder(root->left);
	traversePreorder(root->right);
}

int main()
{
	struct node* root = createNode(39);
	root->left = createNode(29);
	root->right = createNode(49);
	root->left->left = createNode(24);
	root->left->right = createNode(34);
	root->left->left->left = createNode(14);
	root->left->left->right = createNode(27);
	root->right->left = createNode(44);
	root->right->right = createNode(59);
	root->right->right->left = createNode(54);
	root->right->right->right = createNode(69);
	
	cout<<"\n The Preorder traversal of given binary tree is -\n";
	traversePreorder(root);
	return 0;
}

Output

After the execution of the above code, the output will be -

Program: Write a program to implement preorder traversal in C#.

using System;

class Node {
	public int value;
	public Node left, right;

	public Node(int element)
	{
		value = element;
		left = right = null;
	}
}

class BinaryTree {
	Node root;

	BinaryTree() { root = null; }

	void traversePreorder(Node node)
	{
		if (node == null)
			return;
		Console.Write(node.value + " ");
		traversePreorder(node.left);
		traversePreorder(node.right);
	}

	void traversePreorder() { traversePreorder(root); }

	static void Main()
	{
		BinaryTree bt = new BinaryTree();
		bt.root = new Node(38);
		bt.root.left = new Node(28);
		bt.root.right = new Node(48);
		bt.root.left.left = new Node(23);
		bt.root.left.right = new Node(33);
		bt.root.left.left.left = new Node(13);
		bt.root.left.left.right = new Node(26);
		bt.root.right.left = new Node(43);
		bt.root.right.right = new Node(58);
		bt.root.right.right.left = new Node(53);
		bt.root.right.right.right = new Node(68);


		Console.WriteLine("Preorder traversal of given binary tree is - ");
		bt.traversePreorder();
	}
}

Output

After the execution of the above code, the output will be -

Program: Write a program to implement preorder traversal in Java.

class Node {
	public int value;
	public Node left, right;

	public Node(int element)
	{
		value = element;
		left = right = null;
	}
}

class PreorderTraversal {
	Node root;

	PreorderTraversal() { root = null; }

	void traversePreorder(Node node)
	{
		if (node == null)
			return;
		System.out.print(node.value + " ");
		traversePreorder(node.left);
		traversePreorder(node.right);
	}

	void traversePreorder() { traversePreorder(root); }

	public static void main(String args[])
	{
		PreorderTraversal pt = new PreorderTraversal();
		pt.root = new Node(37);
		pt.root.left = new Node(27);
		pt.root.right = new Node(47);
		pt.root.left.left = new Node(22);
		pt.root.left.right = new Node(32);
		pt.root.left.left.left = new Node(12);
		pt.root.left.left.right = new Node(25);
		pt.root.right.left = new Node(42);
		pt.root.right.right = new Node(57);
		pt.root.right.right.left = new Node(52);
		pt.root.right.right.right = new Node(67);

		System.out.println();
		System.out.println("Preorder traversal of given binary tree is - ");
		pt.traversePreorder();
		System.out.println();
	}
}

Output

After the execution of the above code, the output will be -