Unlike linear data structures (Array, Linked List, Queues, Stacks, etc) which have only one logical way to traverse them, trees can be traversed in different ways.
A Tree Data Structure can be traversed in following ways:
- Depth First Search or DFS
- Inorder Traversal
- Preorder Traversal
- Postorder Traversal
- Level Order Traversal or Breadth First Search or BFS
- Boundary Traversal
- Diagonal Traversal
Algorithm Inorder(tree)
- Traverse the left subtree, i.e., call Inorder(left->subtree)
- Visit the root.
- Traverse the right subtree, i.e., call Inorder(right->subtree)
In the case of binary search trees (BST), Inorder traversal gives nodes in non-decreasing order. To get nodes of BST in non-increasing order, a variation of Inorder traversal where Inorder traversal is reversed can be used.
Code implementation of Inorder traversal.
#include <stdio.h>
#include <stdlib.h>
struct node {
int data;
struct node* left;
struct node* right;
};
struct node* newNode(int data)
{
struct node* node
= (struct node*)malloc(sizeof(struct node));
node->data = data;
node->left = NULL;
node->right = NULL;
return (node);
}
void printInorder(struct node* node)
{
if (node == NULL)
return;
printInorder(node->left);
printf("%d ", node->data);
printInorder(node->right);
}
int main()
{
struct node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
printf("Inorder traversal of binary tree is \n");
printInorder(root);
getchar();
return 0;
}
C++
#include <bits/stdc++.h>
usingnamespacestd;
structNode {
intdata;
structNode *left, *right;
};
Node* newNode(intdata)
{
Node* temp =newNode;
temp->data = data;
temp->left = temp->right = NULL;
returntemp;
}
voidprintInorder(structNode* node)
{
if(node == NULL)
return;
printInorder(node->left);
cout << node->data <<" ";
printInorder(node->right);
}
intmain()
{
structNode* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
cout <<"Inorder traversal of binary tree is \n";
printInorder(root);
return0;
}Java
classNode {
intkey;
Node left, right;
publicNode(intitem)
{
key = item;
left = right =null;
}
}
classBinaryTree {
Node root;
BinaryTree() { root =null; }
voidprintInorder(Node node)
{
if(node ==null)
return;
printInorder(node.left);
System.out.print(node.key +" ");
printInorder(node.right);
}
publicstaticvoidmain(String[] args)
{
BinaryTree tree =newBinaryTree();
tree.root =newNode(1);
tree.root.left =newNode(2);
tree.root.right =newNode(3);
tree.root.left.left =newNode(4);
tree.root.left.right =newNode(5);
System.out.println(
"Inorder traversal of binary tree is ");
tree.printInorder(tree.root);
}
}Python3
classNode:
def__init__(self, key):
self.left=None
self.right=None
self.val=key
defprintInorder(root):
ifroot:
printInorder(root.left)
(root.val, end=" "),
printInorder(root.right)
if__name__=="__main__":
root=Node(1)
root.left=Node(2)
root.right=Node(3)
root.left.left=Node(4)
root.left.right=Node(5)
("Inorder traversal of binary tree is")
printInorder(root)C#
usingSystem;
classNode {
publicintkey;
publicNode left, right;
publicNode(intitem)
{
key = item;
left = right =null;
}
}
classBinaryTree {
Node root;
BinaryTree() { root =null; }
voidprintInorder(Node node)
{
if(node ==null)
return;
printInorder(node.left);
Console.Write(node.key +" ");
printInorder(node.right);
}
voidprintInorder() { printInorder(root); }
staticpublicvoidMain(String[] args)
{
BinaryTree tree =newBinaryTree();
tree.root =newNode(1);
tree.root.left =newNode(2);
tree.root.right =newNode(3);
tree.root.left.left =newNode(4);
tree.root.left.right =newNode(5);
Console.WriteLine("Inorder traversal "
+"of binary tree is ");
tree.printInorder();
}
}
Javascript
class Node {
constructor(val) {
this.key = val;
this.left =null;
this.right =null;
}
}
varroot =null;
functionprintInorder(node) {
if(node ==null)
return;
printInorder(node.left);
console.log(node.key +" ");
printInorder(node.right);
}
root =newNode(1);
root.left =newNode(2);
root.right =newNode(3);
root.left.left =newNode(4);
root.left.right =newNode(5);
console.log("Inorder traversal of binary tree is ");
printInorder(root);
Output Inorder traversal of binary tree is 4 2 5 1 3Time Complexity: O(N)
Auxiliary Space: If we don’t consider the size of the stack for function calls then O(1) otherwise O(h) where h is the height of the tree.Algorithm Preorder(tree)
- Visit the root.
- Traverse the left subtree, i.e., call Preorder(left->subtree)
- Traverse the right subtree, i.e., call Preorder(right->subtree)
Uses of Preorder:
Preorder traversal is used to create a copy of the tree. Preorder traversal is also used to get prefix expressions on an expression tree.
Code implementation of Preorder traversal:
C
#include <stdio.h>
#include <stdlib.h>
structnode {
intdata;
structnode* left;
structnode* right;
};
structnode* newNode(intdata)
{
structnode* node
= (structnode*)malloc(sizeof(structnode));
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
voidprintPreorder(structnode* node)
{
if(node == NULL)
return;
printf("%d ", node->data);
printPreorder(node->left);
printPreorder(node->right);
}
intmain()
{
structnode* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
printf("Preorder traversal of binary tree is \n");
printPreorder(root);
getchar();
return0;
}C++
#include <bits/stdc++.h>
usingnamespacestd;
structNode {
intdata;
structNode *left, *right;
};
Node* newNode(intdata)
{
Node* temp =newNode;
temp->data = data;
temp->left = temp->right = NULL;
returntemp;
}
voidprintPreorder(structNode* node)
{
if(node == NULL)
return;
Previous: What is the use of pre-order and post-order traversal ...
Comments
Please Join Us to post.
0