Euler tour of Binary Tree
Given a binary tree where each node can have at most two child nodes, the task is to find the Euler tour of the binary tree. Euler tour is represented by a pointer to the topmost node in the tree. If the tree is empty, then value of root is NULL.
Examples:
Input :
Output: 1 5 4 2 4 3 4 5 1
Approach:
- First, start with root node 1, Euler[0]=1
- Go to left node i.e, node 5, Euler[1]=5
- Go to left node i.e, node 4, Euler[2]=4
- Go to left node i.e, node 2, Euler[3]=2
- Go to left node i.e, NULL, go to parent node 4 Euler[4]=4
- Go to right node i.e, node 3 Euler[5]=3
- No child, go to parent, node 4 Euler[6]=4
- All child discovered, go to parent node 5 Euler[7]=5
- All child discovered, go to parent node 1 Euler[8]=1
Euler tour of tree has been already discussed where it can be applied to N-ary tree which is represented by adjacency list. If a Binary tree is represented by the classical structured way by links and nodes, then there need to first convert the tree into adjacency list representation and then we can find the Euler tour if we want to apply method discussed in the original post. But this increases the space complexity of the program. Here, In this post, a generalized space-optimized version is discussed which can be directly applied to binary trees represented by structure nodes.
This method :
- Works without the use of Visited arrays.
- Requires exactly 2*N-1 vertices to store Euler tour.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node* left;
struct Node* right;
};
struct Node* newNode( int data)
{
struct Node* temp = new struct Node;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
void eulerTree( struct Node* root, vector< int > &Euler)
{
Euler.push_back(root->data);
if (root->left)
{
eulerTree(root->left, Euler);
Euler.push_back(root->data);
}
if (root->right)
{
eulerTree(root->right, Euler);
Euler.push_back(root->data);
}
}
void printEulerTour(Node *root)
{
vector< int > Euler;
eulerTree(root, Euler);
for ( int i = 0; i < Euler.size(); i++)
cout << Euler[i] << " " ;
}
int main()
{
Node* root = newNode(1);
root->left = newNode(2);
root->right = newNode(3);
root->left->left = newNode(4);
root->left->right = newNode(5);
root->right->left = newNode(6);
root->right->right = newNode(7);
root->right->left->right = newNode(8);
printEulerTour(root);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static class Node
{
int data;
Node left;
Node right;
};
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
}
static Vector<Integer> eulerTree(Node root, Vector<Integer> Euler)
{
Euler.add(root.data);
if (root.left != null )
{
Euler = eulerTree(root.left, Euler);
Euler.add(root.data);
}
if (root.right != null )
{
Euler = eulerTree(root.right, Euler);
Euler.add(root.data);
}
return Euler;
}
static void printEulerTour(Node root)
{
Vector<Integer> Euler = new Vector<Integer>();
Euler = eulerTree(root, Euler);
for ( int i = 0 ; i < Euler.size(); i++)
System.out.print(Euler.get(i) + " " );
}
public static void main(String[] args)
{
Node root = newNode( 1 );
root.left = newNode( 2 );
root.right = newNode( 3 );
root.left.left = newNode( 4 );
root.left.right = newNode( 5 );
root.right.left = newNode( 6 );
root.right.right = newNode( 7 );
root.right.left.right = newNode( 8 );
printEulerTour(root);
}
}
|
Python3
class Node:
def __init__( self , key):
self .data = key
self .left = None
self .right = None
def eulerTree(root, euler):
euler.append(root.data)
if root.left:
euler = eulerTree(root.left, euler)
euler.append(root.data)
if root.right:
euler = eulerTree(root.right, euler)
euler.append(root.data)
return euler
def printEulerTour(root):
euler = []
euler = eulerTree(root, euler)
for i in range ( len (euler)):
print (euler[i], end = " " )
root = Node( 1 )
root.left = Node( 2 )
root.right = Node( 3 )
root.left.left = Node( 4 )
root.left.right = Node( 5 )
root.right.left = Node( 6 )
root.right.right = Node( 7 )
root.right.left.right = Node( 8 )
printEulerTour(root)
|
C#
using System;
using System.Collections.Generic;
class GFG
{
public class Node
{
public int data;
public Node left;
public Node right;
};
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
}
static List< int > eulerTree(Node root, List< int > Euler)
{
Euler.Add(root.data);
if (root.left != null )
{
Euler = eulerTree(root.left, Euler);
Euler.Add(root.data);
}
if (root.right != null )
{
Euler = eulerTree(root.right, Euler);
Euler.Add(root.data);
}
return Euler;
}
static void printEulerTour(Node root)
{
List< int > Euler = new List< int >();
Euler = eulerTree(root, Euler);
for ( int i = 0; i < Euler.Count; i++)
Console.Write(Euler[i] + " " );
}
public static void Main(String[] args)
{
Node root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
root.right.left = newNode(6);
root.right.right = newNode(7);
root.right.left.right = newNode(8);
printEulerTour(root);
}
}
|
Javascript
<script>
class Node
{
constructor()
{
this .data = 0;
this .left = null ;
this .right = null ;
}
};
function newNode(data)
{
var temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
}
function eulerTree(root, Euler)
{
Euler.push(root.data);
if (root.left != null )
{
Euler = eulerTree(root.left, Euler);
Euler.push(root.data);
}
if (root.right != null )
{
Euler = eulerTree(root.right, Euler);
Euler.push(root.data);
}
return Euler;
}
function printEulerTour(root)
{
var Euler = [];
Euler = eulerTree(root, Euler);
for ( var i = 0; i < Euler.length; i++)
document.write(Euler[i] + " " );
}
var root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.left.right = newNode(5);
root.right.left = newNode(6);
root.right.right = newNode(7);
root.right.left.right = newNode(8);
printEulerTour(root);
</script>
|
Output
1 2 4 2 5 2 1 3 6 8 6 3 7 3 1
Complexity Analysis:
- Time Complexity: O(2*N-1) where N is number of nodes in the tree.
- Auxiliary Space : O(2*N-1) where N is number of nodes in the tree.
Last Updated :
18 Aug, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...