# Find number of node exist in Euler Tour of Binary Tree

Here given code implementation process.

``````/*
C Program
Find number of node exist in Euler Tour of Binary Tree
*/
#include <stdio.h>
#include <stdlib.h>

// Tree Node
struct TreeNode
{
int data;
struct TreeNode *left;
struct TreeNode *right;
};

// Binary Tree
struct BinaryTree
{
struct TreeNode *root;
};
// Create new tree
struct BinaryTree *new_tree()
{
// Create dynamic node
struct BinaryTree *tree = (struct BinaryTree *) malloc(sizeof(struct BinaryTree));
if (tree != NULL)
{
tree->root = NULL;
}
else
{
printf("Memory Overflow to Create tree Tree\n");
}
//return new tree
return tree;
}
// returns a new node of tree
struct TreeNode *new_node(int data)
{
// Create dynamic node
struct TreeNode *node = (struct TreeNode *) malloc(sizeof(struct TreeNode));
if (node != NULL)
{
//Set data and pointer values
node->data = data;
node->left = NULL;
node->right = NULL;
}
else
{
//This is indicates, segmentation fault or memory overflow problem
printf("Memory Overflow\n");
}
//return new node
return node;
}

// Count the number of nodes in euler path of given tree
int euler_path_node(struct TreeNode*node,struct TreeNode *parent)
{

if(node==NULL)
{
// When tree node empty
return 0;
}
//Recursively executing the left and right subtree and count nodes

int count = euler_path_node(node->left, node) + euler_path_node(node->right, node) + 1;

if(parent != NULL)
{
return count+1;
}
else
{
return count;
}

}

// Handles the request of printing the euler path
void euler_path(struct TreeNode*root)
{

if(root==NULL)
{
printf("\n Empty Tree \n");
}
else
{
int ans = euler_path_node(root,NULL);

printf(" Total Node is : %d\n",ans);
}
}

int main()
{
struct BinaryTree *tree = new_tree();

/*
9
/ \
5   7
/ \   \
1   6   11
/   / \   \
10  4   8   20
\
3
-----------------------
Binary Tree
*/

tree->root = new_node(9);
tree->root->left = new_node(5);
tree->root->right = new_node(7);
tree->root->left->left = new_node(1);
tree->root->left->left->left = new_node(10);
tree->root->left->right = new_node(6);
tree->root->left->right->left = new_node(4);
tree->root->left->right->right = new_node(8);
tree->root->left->right->right->right = new_node(3);
tree->root->right->right = new_node(11);
tree->root->right->right->right = new_node(20);

// Euler path : 9 5 1 10 1 5 6 4 6 8 2 8 3 8 6 5 9 7 11 20 11 7 9
// Output 23
euler_path(tree->root);
return 0;
}
``````

#### Output

`` Total Node is : 21``
``````/*
Java Program
Find number of node exist in Euler Tour of Binary Tree
*/
// Tree Node
class TreeNode
{
public int data;
public TreeNode left;
public TreeNode right;
public TreeNode(int data)
{
this.data = data;
this.left = null;
this.right = null;
}
}
// Binary Tree
public class BinaryTree
{
public TreeNode root;
public BinaryTree()
{
this.root = null;
}
// Count the number of nodes in euler path of given tree
public int euler_path_node(TreeNode node, TreeNode parent)
{
if (node == null)
{
// When tree node empty
return 0;
}
//Recursively executing the left and right subtree and count nodes
int count = euler_path_node(node.left, node) + euler_path_node(node.right, node) + 1;
if (parent != null)
{
return count + 1;
}
else
{
return count;
}
}
// Handles the request of printing the euler path
public void euler_path()
{
if (this.root == null)
{
System.out.print("\n Empty Tree \n");
}
else
{
int ans = euler_path_node(this.root, null);
System.out.print(" Total Node is : " + ans + "\n");
}
}
public static void main(String[] args)
{
BinaryTree tree = new BinaryTree();
/*
9
/ \
5   7
/ \   \
1   6   11
/   / \   \
10  4   8   20
\
3
-----------------------
Binary Tree
*/
tree.root = new TreeNode(9);
tree.root.left = new TreeNode(5);
tree.root.right = new TreeNode(7);
tree.root.left.left = new TreeNode(1);
tree.root.left.left.left = new TreeNode(10);
tree.root.left.right = new TreeNode(6);
tree.root.left.right.left = new TreeNode(4);
tree.root.left.right.right = new TreeNode(8);
tree.root.left.right.right.right = new TreeNode(3);
tree.root.right.right = new TreeNode(11);
tree.root.right.right.right = new TreeNode(20);
tree.euler_path();
}
}``````

#### Output

`` Total Node is : 21``
``````// Include header file
#include <iostream>
using namespace std;

/*
C++ Program
Find number of node exist in Euler Tour of Binary Tree
*/

//  Tree Node
class TreeNode
{
public:
int data;
TreeNode *left;
TreeNode *right;
TreeNode(int data)
{
this->data = data;
this->left = NULL;
this->right = NULL;
}
};
//  Binary Tree
class BinaryTree
{
public:
TreeNode *root;
BinaryTree()
{
this->root = NULL;
}
//  Count the number of nodes in euler path of given tree
int euler_path_node(TreeNode *node, TreeNode *parent)
{
if (node == NULL)
{
//  When tree node empty
return 0;
}
// Recursively executing the left and right subtree and count nodes
int count = this->euler_path_node(node->left, node) + this->euler_path_node(node->right, node) + 1;
if (parent != NULL)
{
return count + 1;
}
else
{
return count;
}
}
//  Handles the request of printing the euler path
void euler_path()
{
if (this->root == NULL)
{
cout << "\n Empty Tree \n";
}
else
{
int ans = this->euler_path_node(this->root, NULL);
cout << " Total Node is : " << ans << "\n";
}
}
};
int main()
{
BinaryTree tree = BinaryTree();
/*
9
/ \
5   7
/ \   \
1   6   11
/   / \   \
10  4   8   20
\
3
-----------------------
Binary Tree
*/
tree.root = new TreeNode(9);
tree.root->left = new TreeNode(5);
tree.root->right = new TreeNode(7);
tree.root->left->left = new TreeNode(1);
tree.root->left->left->left = new TreeNode(10);
tree.root->left->right = new TreeNode(6);
tree.root->left->right->left = new TreeNode(4);
tree.root->left->right->right = new TreeNode(8);
tree.root->left->right->right->right = new TreeNode(3);
tree.root->right->right = new TreeNode(11);
tree.root->right->right->right = new TreeNode(20);
tree.euler_path();
return 0;
}``````

#### Output

`` Total Node is : 21``
``````// Include namespace system
using System;
/*
C# Program
Find number of node exist in Euler Tour of Binary Tree
*/
//  Tree Node
public class TreeNode
{
public int data;
public TreeNode left;
public TreeNode right;
public TreeNode(int data)
{
this.data = data;
this.left = null;
this.right = null;
}
}
//  Binary Tree
public class BinaryTree
{
public TreeNode root;
public BinaryTree()
{
this.root = null;
}
//  Count the number of nodes in euler path of given tree
public int euler_path_node(TreeNode node, TreeNode parent)
{
if (node == null)
{
//  When tree node empty
return 0;
}
// Recursively executing the left and right subtree and count nodes
int count = euler_path_node(node.left, node) + euler_path_node(node.right, node) + 1;
if (parent != null)
{
return count + 1;
}
else
{
return count;
}
}
//  Handles the request of printing the euler path
public void euler_path()
{
if (this.root == null)
{
Console.Write("\n Empty Tree \n");
}
else
{
int ans = euler_path_node(this.root, null);
Console.Write(" Total Node is : " + ans + "\n");
}
}
public static void Main(String[] args)
{
BinaryTree tree = new BinaryTree();
/*
9
/ \
5   7
/ \   \
1   6   11
/   / \   \
10  4   8   20
\
3
-----------------------
Binary Tree
*/
tree.root = new TreeNode(9);
tree.root.left = new TreeNode(5);
tree.root.right = new TreeNode(7);
tree.root.left.left = new TreeNode(1);
tree.root.left.left.left = new TreeNode(10);
tree.root.left.right = new TreeNode(6);
tree.root.left.right.left = new TreeNode(4);
tree.root.left.right.right = new TreeNode(8);
tree.root.left.right.right.right = new TreeNode(3);
tree.root.right.right = new TreeNode(11);
tree.root.right.right.right = new TreeNode(20);
tree.euler_path();
}
}``````

#### Output

`` Total Node is : 21``
``````<?php
/*
Php Program
Find number of node exist in Euler Tour of Binary Tree
*/
//  Tree Node
class TreeNode
{
public \$data;
public \$left;
public \$right;

function __construct(\$data)
{
\$this->data = \$data;
\$this->left = null;
\$this->right = null;
}
}
//  Binary Tree
class BinaryTree
{
public \$root;

function __construct()
{
\$this->root = null;
}
//  Count the number of nodes in euler path of given tree
public  function euler_path_node(\$node, \$parent)
{
if (\$node == null)
{
//  When tree node empty
return 0;
}
// Recursively executing the left and right subtree and count nodes
\$count = \$this->euler_path_node(\$node->left, \$node) + \$this->euler_path_node(\$node->right, \$node) + 1;
if (\$parent != null)
{
return \$count + 1;
}
else
{
return \$count;
}
}
//  Handles the request of printing the euler path
public  function euler_path()
{
if (\$this->root == null)
{
echo "\n Empty Tree \n";
}
else
{
\$ans = \$this->euler_path_node(\$this->root, null);
echo " Total Node is : ". \$ans ."\n";
}
}
}

function main()
{
\$tree = new BinaryTree();
/*
9
/ \
5   7
/ \   \
1   6   11
/   / \   \
10  4   8   20
\
3
-----------------------
Binary Tree
*/
\$tree->root = new TreeNode(9);
\$tree->root->left = new TreeNode(5);
\$tree->root->right = new TreeNode(7);
\$tree->root->left->left = new TreeNode(1);
\$tree->root->left->left->left = new TreeNode(10);
\$tree->root->left->right = new TreeNode(6);
\$tree->root->left->right->left = new TreeNode(4);
\$tree->root->left->right->right = new TreeNode(8);
\$tree->root->left->right->right->right = new TreeNode(3);
\$tree->root->right->right = new TreeNode(11);
\$tree->root->right->right->right = new TreeNode(20);
\$tree->euler_path();
}
main();``````

#### Output

`` Total Node is : 21``
``````/*
Node Js Program
Find number of node exist in Euler Tour of Binary Tree
*/
//  Tree Node
class TreeNode
{
constructor(data)
{
this.data = data;
this.left = null;
this.right = null;
}
}
//  Binary Tree
class BinaryTree
{
constructor()
{
this.root = null;
}
//  Count the number of nodes in euler path of given tree
euler_path_node(node, parent)
{
if (node == null)
{
//  When tree node empty
return 0;
}
// Recursively executing the left and right subtree and count nodes
var count = this.euler_path_node(node.left, node) + this.euler_path_node(node.right, node) + 1;
if (parent != null)
{
return count + 1;
}
else
{
return count;
}
}
//  Handles the request of printing the euler path
euler_path()
{
if (this.root == null)
{
process.stdout.write("\n Empty Tree \n");
}
else
{
var ans = this.euler_path_node(this.root, null);
process.stdout.write(" Total Node is : " + ans + "\n");
}
}
}

function main()
{
var tree = new BinaryTree();
/*
9
/ \
5   7
/ \   \
1   6   11
/   / \   \
10  4   8   20
\
3
-----------------------
Binary Tree
*/
tree.root = new TreeNode(9);
tree.root.left = new TreeNode(5);
tree.root.right = new TreeNode(7);
tree.root.left.left = new TreeNode(1);
tree.root.left.left.left = new TreeNode(10);
tree.root.left.right = new TreeNode(6);
tree.root.left.right.left = new TreeNode(4);
tree.root.left.right.right = new TreeNode(8);
tree.root.left.right.right.right = new TreeNode(3);
tree.root.right.right = new TreeNode(11);
tree.root.right.right.right = new TreeNode(20);
tree.euler_path();
}
main();``````

#### Output

`` Total Node is : 21``
``````#  Python 3 Program
#  Find number of node exist in Euler Tour of Binary Tree

#  Tree Node
class TreeNode :

def __init__(self, data) :
self.data = data
self.left = None
self.right = None

#  Binary Tree
class BinaryTree :

def __init__(self) :
self.root = None

#  Count the number of nodes in euler path of given tree
def euler_path_node(self, node, parent) :
if (node == None) :
#  When tree node empty
return 0

# Recursively executing the left and right subtree and count nodes
count = self.euler_path_node(node.left, node) + self.euler_path_node(node.right, node) + 1
if (parent != None) :
return count + 1
else :
return count

#  Handles the request of printing the euler path
def euler_path(self) :
if (self.root == None) :
print("\n Empty Tree \n", end = "")
else :
ans = self.euler_path_node(self.root, None)
print(" Total Node is : ", ans ,"\n", end = "")

def main() :
tree = BinaryTree()
#
# 		        9
# 		       / \
# 		      5   7
# 		     / \   \
# 		    1   6   11
# 		   /   / \   \
# 		  10  4   8   20
# 		           \
# 		            3
# 		-----------------------
# 		    Binary Tree
#

tree.root = TreeNode(9)
tree.root.left = TreeNode(5)
tree.root.right = TreeNode(7)
tree.root.left.left = TreeNode(1)
tree.root.left.left.left = TreeNode(10)
tree.root.left.right = TreeNode(6)
tree.root.left.right.left = TreeNode(4)
tree.root.left.right.right = TreeNode(8)
tree.root.left.right.right.right = TreeNode(3)
tree.root.right.right = TreeNode(11)
tree.root.right.right.right = TreeNode(20)
tree.euler_path()

if __name__ == "__main__": main()``````

#### Output

`` Total Node is :  21``
``````#  Ruby Program
#  Find number of node exist in Euler Tour of Binary Tree

#  Tree Node
class TreeNode
# Define the accessor and reader of class TreeNode
attr_accessor :data, :left, :right

def initialize(data)
self.data = data
self.left = nil
self.right = nil
end

end

#  Binary Tree
class BinaryTree
# Define the accessor and reader of class BinaryTree
attr_accessor :root

def initialize()
self.root = nil
end

#  Count the number of nodes in euler path of given tree
def euler_path_node(node, parent)
if (node == nil)
#  When tree node empty
return 0
end

# Recursively executing the left and right subtree and count nodes
count = self.euler_path_node(node.left, node) + self.euler_path_node(node.right, node) + 1
if (parent != nil)
return count + 1
else
return count
end

end

#  Handles the request of printing the euler path
def euler_path()
if (self.root == nil)
print("\n Empty Tree \n")
else
ans = self.euler_path_node(self.root, nil)
print(" Total Node is : ", ans ,"\n")
end

end

end

def main()
tree = BinaryTree.new()
#
# 		        9
# 		       / \
# 		      5   7
# 		     / \   \
# 		    1   6   11
# 		   /   / \   \
# 		  10  4   8   20
# 		           \
# 		            3
# 		-----------------------
# 		    Binary Tree
#

tree.root = TreeNode.new(9)
tree.root.left = TreeNode.new(5)
tree.root.right = TreeNode.new(7)
tree.root.left.left = TreeNode.new(1)
tree.root.left.left.left = TreeNode.new(10)
tree.root.left.right = TreeNode.new(6)
tree.root.left.right.left = TreeNode.new(4)
tree.root.left.right.right = TreeNode.new(8)
tree.root.left.right.right.right = TreeNode.new(3)
tree.root.right.right = TreeNode.new(11)
tree.root.right.right.right = TreeNode.new(20)
tree.euler_path()
end

main()``````

#### Output

`````` Total Node is : 21
``````
``````/*
Scala Program
Find number of node exist in Euler Tour of Binary Tree
*/
//  Tree Node
class TreeNode(var data: Int , var left: TreeNode , var right: TreeNode)
{
def this(data: Int)
{
this(data, null, null);
}
}
//  Binary Tree
class BinaryTree(var root: TreeNode)
{
def this()
{
this(null);
}
//  Count the number of nodes in euler path of given tree
def euler_path_node(node: TreeNode, parent: TreeNode): Int = {
if (node == null)
{
//  When tree node empty
return 0;
}
// Recursively executing the left and right subtree and count nodes
var count: Int = euler_path_node(node.left, node) + euler_path_node(node.right, node) + 1;
if (parent != null)
{
return count + 1;
}
else
{
return count;
}
}
//  Handles the request of printing the euler path
def euler_path(): Unit = {
if (this.root == null)
{
print("\n Empty Tree \n");
}
else
{
var ans: Int = euler_path_node(this.root, null);
print(" Total Node is : " + ans + "\n");
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var tree: BinaryTree = new BinaryTree();
/*
9
/ \
5   7
/ \   \
1   6   11
/   / \   \
10  4   8   20
\
3
-----------------------
Binary Tree
*/
tree.root = new TreeNode(9);
tree.root.left = new TreeNode(5);
tree.root.right = new TreeNode(7);
tree.root.left.left = new TreeNode(1);
tree.root.left.left.left = new TreeNode(10);
tree.root.left.right = new TreeNode(6);
tree.root.left.right.left = new TreeNode(4);
tree.root.left.right.right = new TreeNode(8);
tree.root.left.right.right.right = new TreeNode(3);
tree.root.right.right = new TreeNode(11);
tree.root.right.right.right = new TreeNode(20);
tree.euler_path();
}
}``````

#### Output

`` Total Node is : 21``
``````/*
Swift 4 Program
Find number of node exist in Euler Tour of Binary Tree
*/
//  Tree Node
class TreeNode
{
var data: Int;
var left: TreeNode? ;
var right: TreeNode? ;
init(_ data: Int)
{
self.data = data;
self.left = nil;
self.right = nil;
}
}
//  Binary Tree
class BinaryTree
{
var root: TreeNode? ;
init()
{
self.root = nil;
}
//  Count the number of nodes in euler path of given tree
func euler_path_node(_ node: TreeNode? , _ parent : TreeNode? )->Int
{
if (node == nil)
{
//  When tree node empty
return 0;
}
// Recursively executing the left and right subtree and count nodes
let count: Int = self.euler_path_node(node!.left, node) + self.euler_path_node(node!.right, node) + 1;
if (parent != nil)
{
return count + 1;
}
else
{
return count;
}
}
//  Handles the request of printing the euler path
func euler_path()
{
if (self.root == nil)
{
print("\n Empty Tree \n", terminator: "");
}
else
{
let ans: Int = self.euler_path_node(self.root, nil);
print(" Total Node is : ", ans ,"\n", terminator: "");
}
}
}
func main()
{
let tree: BinaryTree = BinaryTree();
/*
9
/ \
5   7
/ \   \
1   6   11
/   / \   \
10  4   8   20
\
3
-----------------------
Binary Tree
*/
tree.root = TreeNode(9);
tree.root!.left = TreeNode(5);
tree.root!.right = TreeNode(7);
tree.root!.left!.left = TreeNode(1);
tree.root!.left!.left!.left = TreeNode(10);
tree.root!.left!.right = TreeNode(6);
tree.root!.left!.right!.left = TreeNode(4);
tree.root!.left!.right!.right = TreeNode(8);
tree.root!.left!.right!.right!.right = TreeNode(3);
tree.root!.right!.right = TreeNode(11);
tree.root!.right!.right!.right = TreeNode(20);
tree.euler_path();
}
main();``````

#### Output

`` Total Node is :  21``

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.