Mix Order Traversal of a Binary Tree
Last Updated :
03 May, 2023
Given a Binary Tree consisting of N nodes, the task is to print its Mix Order Traversal.
Mix Order Traversal is a tree traversal technique, which involves any two of the existing traversal techniques like Inorder, Preorder and Postorder Traversal. Any two of them can be performed or alternate levels of given tree and a mix traversal can be obtained.
Examples:
Input: N = 6
Output: 7 4 5 1 3 6
Explanation:
Inorder-Preorder Mix Traversal is applied to the given tree in the following order:
Inorder Traversal is applied at level 0
Preorder Traversal is applied at level 1
Inorder Traversal at level 2.
Output: 4 5 7 1 6 3
Explanation:
Inorder-Postorder Mix Traversal is applied to the given tree in the following order:
Inorder Traversal is applied at level 0
Postorder Traversal is applied at level 1
Inorder Traversal at level 2.
Approach:
The possible Mix Order Traversals are as follows:
Inorder-Preorder Mix Traversal
Steps for inorder() will be:
- Perform Preorder Traversal on the left subtree.
- Print the current node.
- Perform Preorder Traversal on right subtree.
Steps for preorder() will be:
- Print the current node.
- Perform Inorder Traversal on left subtree(root->left).
- Perform Inorder Traversal on right subtree.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void inOrder( struct node* root);
void preOrder( struct node* root);
struct node {
char data;
struct node *left, *right;
};
struct node* newNode( char ch)
{
struct node* n = ( struct node*)
malloc ( sizeof ( struct node));
n->data = ch;
n->left = NULL;
n->right = NULL;
return n;
}
void inOrder( struct node* root)
{
if (root) {
preOrder(root->left);
cout << root->data << " " ;
preOrder(root->right);
}
}
void preOrder( struct node* root)
{
if (root) {
cout << root->data << " " ;
inOrder(root->left);
inOrder(root->right);
}
}
int main()
{
struct node* root = newNode( '1' );
root->left = newNode( '7' );
root->right = newNode( '3' );
root->left->left = newNode( '4' );
root->left->right = newNode( '5' );
root->right->left = newNode( '6' );
inOrder(root);
return 0;
}
|
Java
import java.util.*;
class GFG{
static class node
{
char data;
node left, right;
};
static node newNode( char ch)
{
node n = new node();
n.data = ch;
n.left = null ;
n.right = null ;
return n;
}
static void inOrder(node root)
{
if (root != null )
{
preOrder(root.left);
System.out.print(root.data + " " );
preOrder(root.right);
}
}
static void preOrder(node root)
{
if (root != null )
{
System.out.print(root.data + " " );
inOrder(root.left);
inOrder(root.right);
}
}
public static void main(String[] args)
{
node root = newNode( '1' );
root.left = newNode( '7' );
root.right = newNode( '3' );
root.left.left = newNode( '4' );
root.left.right = newNode( '5' );
root.right.left = newNode( '6' );
inOrder(root);
}
}
|
Python3
class node:
def __init__( self ):
self .data = 0
self .left = None
self .right = None
def newNode(ch):
n = node()
n.data = ch
n.left = None
n.right = None
return n
def inOrder(root):
if root ! = None :
preOrder(root.left)
print (root.data, end = " " )
preOrder(root.right)
def preOrder(root):
if root ! = None :
print (root.data, end = " " )
inOrder(root.left)
inOrder(root.right)
root = newNode( '1' )
root.left = newNode( '7' )
root.right = newNode( '3' )
root.left.left = newNode( '4' )
root.left.right = newNode( '5' )
root.right.left = newNode( '6' )
inOrder(root)
|
C#
using System;
class GFG{
class node
{
public char data;
public node left, right;
};
static node newNode( char ch)
{
node n = new node();
n.data = ch;
n.left = null ;
n.right = null ;
return n;
}
static void inOrder(node root)
{
if (root != null )
{
preOrder(root.left);
Console.Write(root.data + " " );
preOrder(root.right);
}
}
static void preOrder(node root)
{
if (root != null )
{
Console.Write(root.data + " " );
inOrder(root.left);
inOrder(root.right);
}
}
public static void Main(String[] args)
{
node root = newNode( '1' );
root.left = newNode( '7' );
root.right = newNode( '3' );
root.left.left = newNode( '4' );
root.left.right = newNode( '5' );
root.right.left = newNode( '6' );
inOrder(root);
}
}
|
Javascript
<script>
class node
{
constructor()
{
this .data = 0;
this .left = null ;
this .right = null ;
}
};
function newNode(ch)
{
var n = new node();
n.data = ch;
n.left = null ;
n.right = null ;
return n;
}
function inOrder(root)
{
if (root != null )
{
preOrder(root.left);
document.write(root.data + " " );
preOrder(root.right);
}
}
function preOrder(root)
{
if (root != null )
{
document.write(root.data + " " );
inOrder(root.left);
inOrder(root.right);
}
}
var root = newNode( '1' );
root.left = newNode( '7' );
root.right = newNode( '3' );
root.left.left = newNode( '4' );
root.left.right = newNode( '5' );
root.right.left = newNode( '6' );
inOrder(root);
</script>
|
The time complexity for both inOrder and preOrder traversals is O(n), where n is the number of nodes in the tree. This is because each node is visited once.
Auxiliary space complexity:
The auxiliary space of newNode function is O(1), because it only allocates memory for a single node.
The auxiliary space complexity of inOrder and preOrder functions is O(h), where h is the height of the tree.
Preorder-Postorder Mix Traversal
Steps for preorder() are as follows:
- Print the current node.
- Perform Postorder traversal on left subtree.
- Perform Postorder Traversal on the right subtree.
Steps for postorder() are as follows:
- Perform preorder traversal on the left subtree.
- Perform preorder traversal on right subtree.
- Print the current node.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void preOrder( struct node* root);
void postOrder( struct node* root);
struct node {
char data;
struct node *left, *right;
};
struct node* newNode( char ch)
{
struct node* n = ( struct node*)
malloc ( sizeof ( struct node));
n->data = ch;
n->left = NULL;
n->right = NULL;
return n;
}
void preOrder( struct node* root)
{
if (root) {
cout << root->data << " " ;
postOrder(root->left);
postOrder(root->right);
}
}
void postOrder( struct node* root)
{
if (root) {
preOrder(root->left);
preOrder(root->right);
cout << root->data << " " ;
}
}
int main()
{
struct node* root = newNode( 'A' );
root->left = newNode( 'B' );
root->right = newNode( 'C' );
root->left->left = newNode( 'F' );
root->left->right = newNode( 'D' );
root->right->right = newNode( 'E' );
preOrder(root);
return 0;
}
|
Java
class GFG{
static class node
{
char data;
node left, right;
};
static node newNode( char ch)
{
node n = new node();
n.data = ch;
n.left = null ;
n.right = null ;
return n;
}
static void preOrder(node root)
{
if (root != null )
{
System.out.print(root.data + " " );
postOrder(root.left);
postOrder(root.right);
}
}
static void postOrder(node root)
{
if (root != null )
{
preOrder(root.left);
preOrder(root.right);
System.out.print(root.data + " " );
}
}
public static void main(String[] args)
{
node root = newNode( 'A' );
root.left = newNode( 'B' );
root.right = newNode( 'C' );
root.left.left = newNode( 'F' );
root.left.right = newNode( 'D' );
root.right.right = newNode( 'E' );
preOrder(root);
}
}
|
Python3
class node:
def __init__( self ):
self .data = '0'
self .left = None
self .right = None
def newNode(ch):
n = node()
n.data = ch
n.left = None
n.right = None
return n
def preOrder(root):
if root ! = None :
print (root.data, end = " " )
postOrder(root.left)
postOrder(root.right)
def postOrder(root):
if root ! = None :
preOrder(root.left)
preOrder(root.right)
print (root.data, end = " " )
root = newNode( 'A' )
root.left = newNode( 'B' )
root.right = newNode( 'C' )
root.left.left = newNode( 'F' )
root.left.right = newNode( 'D' )
root.right.right = newNode( 'E' )
preOrder(root)
|
C#
using System;
class GFG{
class node
{
public char data;
public node left, right;
};
static node newNode( char ch)
{
node n = new node();
n.data = ch;
n.left = null ;
n.right = null ;
return n;
}
static void preOrder(node root)
{
if (root != null )
{
Console.Write(root.data + " " );
postOrder(root.left);
postOrder(root.right);
}
}
static void postOrder(node root)
{
if (root != null )
{
preOrder(root.left);
preOrder(root.right);
Console.Write(root.data + " " );
}
}
public static void Main(String[] args)
{
node root = newNode( 'A' );
root.left = newNode( 'B' );
root.right = newNode( 'C' );
root.left.left = newNode( 'F' );
root.left.right = newNode( 'D' );
root.right.right = newNode( 'E' );
preOrder(root);
}
}
|
Javascript
<script>
class node
{
constructor() {
this .left;
this .right;
this .data;
}
}
function newNode(ch)
{
let n = new node();
n.data = ch;
n.left = null ;
n.right = null ;
return n;
}
function preOrder(root)
{
if (root != null )
{
document.write(root.data + " " );
postOrder(root.left);
postOrder(root.right);
}
}
function postOrder(root)
{
if (root != null )
{
preOrder(root.left);
preOrder(root.right);
document.write(root.data + " " );
}
}
let root = newNode( 'A' );
root.left = newNode( 'B' );
root.right = newNode( 'C' );
root.left.left = newNode( 'F' );
root.left.right = newNode( 'D' );
root.right.right = newNode( 'E' );
preOrder(root);
</script>
|
Time Complexity: O(N) where N is the number of nodes in the tree.
Auxiliary Space: O(log(N))
Inorder-Postorder Mix Traversal
Steps for inorder() are as follows:
- Perform Postorder Traversal on the left subtree.
- Print the current node.
- Perform Postorder Traversal on the right subtree.
Steps for postorder() will be:
- Perform Inorder Traversal on left subtree.
- Perform Inorder Traversal on right subtree.
- Print the current node.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void inOrder( struct node* root);
void postOrder( struct node* root);
struct node {
char data;
struct node *left, *right;
};
struct node* newNode( char ch)
{
struct node* n = ( struct node*)
malloc ( sizeof ( struct node));
n->data = ch;
n->left = NULL;
n->right = NULL;
return n;
}
void inOrder( struct node* root)
{
if (root) {
postOrder(root->left);
cout << root->data << " " ;
postOrder(root->right);
}
}
void postOrder( struct node* root)
{
if (root) {
inOrder(root->left);
inOrder(root->right);
cout << root->data << " " ;
}
}
int main()
{
struct node* root = newNode( 'A' );
root->left = newNode( 'B' );
root->right = newNode( 'C' );
root->left->left = newNode( 'F' );
root->left->right = newNode( 'D' );
root->right->right = newNode( 'E' );
inOrder(root);
return 0;
}
|
Java
import java.util.*;
class GFG{
static class node
{
char data;
node left, right;
};
static node newNode( char ch)
{
node n = new node();
n.data = ch;
n.left = null ;
n.right = null ;
return n;
}
static void inOrder(node root)
{
if (root != null )
{
postOrder(root.left);
System.out.print(root.data + " " );
postOrder(root.right);
}
}
static void postOrder(node root)
{
if (root != null )
{
inOrder(root.left);
inOrder(root.right);
System.out.print(root.data + " " );
}
}
public static void main(String[] args)
{
node root = newNode( 'A' );
root.left = newNode( 'B' );
root.right = newNode( 'C' );
root.left.left = newNode( 'F' );
root.left.right = newNode( 'D' );
root.right.right = newNode( 'E' );
inOrder(root);
}
}
|
Python3
class node:
def __init__( self ):
self .data = '0'
self .left = None
self .right = None
def newNode(ch):
n = node()
n.data = ch
n.left = None
n.right = None
return n
def inOrder(root):
if root ! = None :
postOrder(root.left)
print (root.data, end = " " )
postOrder(root.right)
def postOrder(root):
if root ! = None :
inOrder(root.left)
inOrder(root.right)
print (root.data, end = " " )
root = newNode( 'A' )
root.left = newNode( 'B' )
root.right = newNode( 'C' )
root.left.left = newNode( 'F' )
root.left.right = newNode( 'D' )
root.right.right = newNode( 'E' )
inOrder(root)
|
C#
using System;
class GFG{
class node
{
public char data;
public node left, right;
};
static node newNode( char ch)
{
node n = new node();
n.data = ch;
n.left = null ;
n.right = null ;
return n;
}
static void inOrder(node root)
{
if (root != null )
{
postOrder(root.left);
Console.Write(root.data + " " );
postOrder(root.right);
}
}
static void postOrder(node root)
{
if (root != null )
{
inOrder(root.left);
inOrder(root.right);
Console.Write(root.data + " " );
}
}
public static void Main(String[] args)
{
node root = newNode( 'A' );
root.left = newNode( 'B' );
root.right = newNode( 'C' );
root.left.left = newNode( 'F' );
root.left.right = newNode( 'D' );
root.right.right = newNode( 'E' );
inOrder(root);
}
}
|
Javascript
<script>
class node
{
constructor() {
this .left;
this .right;
this .data;
}
}
function newNode(ch)
{
let n = new node();
n.data = ch;
n.left = null ;
n.right = null ;
return n;
}
function inOrder(root)
{
if (root != null )
{
postOrder(root.left);
document.write(root.data + " " );
postOrder(root.right);
}
}
function postOrder(root)
{
if (root != null )
{
inOrder(root.left);
inOrder(root.right);
document.write(root.data + " " );
}
}
let root = newNode( 'A' );
root.left = newNode( 'B' );
root.right = newNode( 'C' );
root.left.left = newNode( 'F' );
root.left.right = newNode( 'D' );
root.right.right = newNode( 'E' );
inOrder(root);
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...