Related Articles

# Euler tour of Binary Tree

• Difficulty Level : Easy
• Last Updated : 23 Jun, 2021

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:

(2) Go to left node i.e, node 5, Euler[1]=5
(3) Go to left node i.e, node 4, Euler[2]=4
(4) Go to left node i.e, node 2, Euler[3]=2
(5) Go to left node i.e, NULL, go to parent node 4 Euler[4]=4
(6) Go to right node i.e, node 3 Euler[5]=3
(7) No child, go to parent, node 4 Euler[6]=4
(8) All child discovered, go to parent node 5 Euler[7]=5
(9) 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 :
(1) Works without the use of Visited arrays.
(2) Requires exactly 2*N-1 vertices to store Euler tour.

## C++

 `// C++ program to find euler tour of binary tree``#include ``using` `namespace` `std;` `/* A tree node structure */``struct` `Node {``    ``int` `data;``    ``struct` `Node* left;``    ``struct` `Node* right;``};` `/* Utility function to create a new Binary Tree node */``struct` `Node* newNode(``int` `data)``{``    ``struct` `Node* temp = ``new` `struct` `Node;``    ``temp->data = data;``    ``temp->left = temp->right = NULL;``    ``return` `temp;``}` `// Find Euler Tour``void` `eulerTree(``struct` `Node* root, vector<``int``> &Euler)``{``    ``// store current node's data``    ``Euler.push_back(root->data);` `    ``// If left node exists``    ``if` `(root->left)``    ``{``        ``// traverse left subtree``        ``eulerTree(root->left, Euler);` `        ``// store parent node's data``        ``Euler.push_back(root->data);``    ``}` `    ``// If right node exists``    ``if` `(root->right)``    ``{``        ``// traverse right subtree``        ``eulerTree(root->right, Euler);` `        ``// store parent node's data``        ``Euler.push_back(root->data);``    ``}``}` `// Function to print Euler Tour of tree``void` `printEulerTour(Node *root)``{``    ``// Stores Euler Tour``    ``vector<``int``> Euler;` `    ``eulerTree(root, Euler);` `    ``for` `(``int` `i = 0; i < Euler.size(); i++)``        ``cout << Euler[i] << ``" "``;``}` `/* Driver function to test above functions */``int` `main()``{``    ``// Constructing tree given in the above figure``    ``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);` `    ``// print Euler Tour``    ``printEulerTour(root);` `    ``return` `0;``}`

## Java

 `// Java program to find euler tour of binary tree``import` `java.util.*;` `class` `GFG``{` `    ``/* A tree node structure */``    ``static` `class` `Node``    ``{``        ``int` `data;``        ``Node left;``        ``Node right;``    ``};` `    ``/* Utility function to create a new Binary Tree node */``    ``static` `Node newNode(``int` `data)``    ``{``        ``Node temp = ``new` `Node();``        ``temp.data = data;``        ``temp.left = temp.right = ``null``;``        ``return` `temp;``    ``}` `    ``// Find Euler Tour``    ``static` `Vector eulerTree(Node root, Vector Euler)``    ``{``        ``// store current node's data``        ``Euler.add(root.data);` `        ``// If left node exists``        ``if` `(root.left != ``null``)``        ``{``            ``// traverse left subtree``            ``Euler = eulerTree(root.left, Euler);` `            ``// store parent node's data``            ``Euler.add(root.data);``        ``}` `        ``// If right node exists``        ``if` `(root.right != ``null``)``        ``{``            ``// traverse right subtree``            ``Euler = eulerTree(root.right, Euler);` `            ``// store parent node's data``            ``Euler.add(root.data);``        ``}``        ``return` `Euler;``    ``}` `    ``// Function to print Euler Tour of tree``    ``static` `void` `printEulerTour(Node root)``    ``{``        ``// Stores Euler Tour``        ``Vector Euler = ``new` `Vector();` `        ``Euler = eulerTree(root, Euler);` `        ``for` `(``int` `i = ``0``; i < Euler.size(); i++)``            ``System.out.print(Euler.get(i) + ``" "``);``    ``}` `    ``/* Driver function to test above functions */``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Constructing tree given in the above figure``        ``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``);` `        ``// print Euler Tour``        ``printEulerTour(root);` `    ``}``}` `// This code is contributed by Rajput-Ji`

## C#

 `// C# program to find euler tour of binary tree``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `    ``/* A tree node structure */``    ``public` `class` `Node``    ``{``        ``public` `int` `data;``        ``public` `Node left;``        ``public` `Node right;``    ``};` `    ``/* Utility function to create a new Binary Tree node */``    ``static` `Node newNode(``int` `data)``    ``{``        ``Node temp = ``new` `Node();``        ``temp.data = data;``        ``temp.left = temp.right = ``null``;``        ``return` `temp;``    ``}` `    ``// Find Euler Tour``    ``static` `List<``int``> eulerTree(Node root, List<``int``> Euler)``    ``{``        ``// store current node's data``        ``Euler.Add(root.data);` `        ``// If left node exists``        ``if` `(root.left != ``null``)``        ``{``            ``// traverse left subtree``            ``Euler = eulerTree(root.left, Euler);` `            ``// store parent node's data``            ``Euler.Add(root.data);``        ``}` `        ``// If right node exists``        ``if` `(root.right != ``null``)``        ``{``            ``// traverse right subtree``            ``Euler = eulerTree(root.right, Euler);` `            ``// store parent node's data``            ``Euler.Add(root.data);``        ``}``        ``return` `Euler;``    ``}` `    ``// Function to print Euler Tour of tree``    ``static` `void` `printEulerTour(Node root)``    ``{``        ``// Stores Euler Tour``        ``List<``int``> Euler = ``new` `List<``int``>();` `        ``Euler = eulerTree(root, Euler);` `        ``for` `(``int` `i = 0; i < Euler.Count; i++)``            ``Console.Write(Euler[i] + ``" "``);``    ``}` `    ``/* Driver function to test above functions */``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``// Constructing tree given in the above figure``        ``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);` `        ``// print Euler Tour``        ``printEulerTour(root);` `    ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``
Output:
`1 2 4 2 5 2 1 3 6 8 6 3 7 3 1`

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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up