Formula to Find a Level of the Node in a Binary Tree

The binary tree is a fundamental data structure in the DSA field. Its numerous applications include data organization, searching, and sorting algorithms. With the concept of node levels, finding an efficient and applicable formula to calculate the node level has become very easy.

The level node in a binary tree can be majorly defined as the level node that is basically located at some depth or down the lane. It is basically present at a specific level and is used for the optimization of the tree. Each level that is present in the binary tree contains a level where the tree is present at an equal distance from the root node from all the nodes.

Some advantages of the level node are stated below: -

When we locate a level node, we are basically visualizing the aid for it. We can easily use this information for determining and performing the visual representation and building the diagrams for the same.
It is also very useful in subset processing; suppose we have to isolate a particular node, then we have to look for the subsets, and we can easily focus on them and process them too.
In case we need to perform a certain level of operations and techniques at a certain level of the tree, then it can easily optimize such operations in the tree.

Implementation

// Writing a C++ program that will help us get the node of a binary tree. 
#include <bits/stdc++.h>
using namespace std;

/* Creating a tree that will contain a node structure */
struct __nod {
	int record;
	struct __nod* Lft;
	struct __nod* Rt;
};
// Creating a helper function to help us get the binary tree's level. The level of the given data is already present in the tree; if not, we can return 0.
int getLevelUtil(struct __nod* __nod, int record, int level)
{
	if (__nod == NILL)
		return 0;

	if (__nod->record == record)
		return level;

	int downlevel
		= getLevelUtil(__nod->Lft, record, level + 1);
	if (downlevel != 0)
		return downlevel;

	downlevel = getLevelUtil(__nod->Rt, record, level + 1);
	return downlevel;
}

/* We have to return the value of the given record */
int getLevel(struct __nod* __nod, int record)
{
	return getLevelUtil(__nod, record, 1);
}

// Now, we must create the Utility function to help us create a new binary tree data. 
struct __nod* new__nod(int record)
{
	struct __nod* temp = new struct __nod;
	temp->record = record;
	temp->Lft = NILL;
	temp->Rt = NILL;
	return temp;
}

// Writing the main code to see the above approach
int main()
{
	struct __nod* root = new struct __nod;
	int x;

	// Constructing tree is given in the above figure
	root = new__nod(3);
	root->Lft = new__nod(2);
	root->Rt = new__nod(5);
	root->Lft->Lft = new__nod(1);
	root->Lft->Rt = new__nod(4);

	for (x = 1; x <= 5; x++) {
		int level = getLevel(root, x);
		if (level)
			cout << "Level of " << x << " is " << level
				<< endl;
		else
			cout << x << "is not present in tree" << endl;
	}

	getchar();
	return 0;
}

Output

Formula to Find a Level of the Node in a Binary Tree

A step-by-step explanation of the code

The code begins by declaring the necessary header files.
The code defines a structure for the binary tree with the struct keyword, and it has the following members: a data value and a pointer to the left and right child.
We will now create a getLevelUtil function which turns out to be a helper function. It has three parameters: node, data, and level.
The 'getLevel' function has two parameters node and data.
Now, we declare a 'newNode' function that helps us create a new node in the binary tree, and it usually takes a single parameter, data, and sets the left and right pointers to NILL.
In the program's primary function, the pointer 'root' is created to store the root of the binary tree.
The binary tree is built by assigning positions in the tree.
We create a for loop, which iterates over the values from 1 to 5. For each one of these values, the 'get level' function is called to find the level in the binary tree. If the value is non-zero, the value will be present in the tree. Otherwise, a message indicating the value is not present in the tree is printed.
'getchar()' is used to wait for a character input before the program ends or terminates.
The program ends by returning the value 0 from the main function indicating the execution of the program.

Example 2)

// Writing a Java program that will help us get the node of a binary tree. 
/* Creating a tree that will contain a node structure */
class __nod {
	int record;
	__nod Lft, Rt;

	public __nod(int d)
	{
		record = d;
		Lft = Rt = NILL;
	}
}

class BinaryTree {

	__nod root;

// Creating a helper function to help us get the binary tree's level. The level of the given data is already present in the tree; if not, we can return 0.
	int getLevelUtil(__nod __nod, int record, int level)
	{
		if (__nod == NILL)
			return 0;

		if (__nod.record == record)
			return level;

		int downlevel
			= getLevelUtil(__nod.Lft, record, level + 1);
		if (downlevel != 0)
			return downlevel;

		downlevel
			= getLevelUtil(__nod.Rt, record, level + 1);
		return downlevel;
	}

/* We have to return the value of the given record */
// Now, we must create the Utility function to help us create a new binary tree data. 
	int getLevel(__nod __nod, int record)
	{
		return getLevelUtil(__nod, record, 1);
	}

// Writing the main code to see the above approach
	public static void main(String[] args)
	{
		BinaryTree tree = new BinaryTree();

		/* Constructing tree is given in the above figure */
		tree.root = new __nod(3);
		tree.root.Lft = new __nod(2);
		tree.root.Rt = new __nod(5);
		tree.root.Lft.Lft = new __nod(1);
		tree.root.Lft.Rt = new __nod(4);
		for (int x = 1; x <= 5; x++) {
			int level = tree.getLevel(tree.root, x);
			if (level != 0)
				System.out.println(
					"Level of " + x + " is "
					+ tree.getLevel(tree.root, x));
			else
				System.out.println(
					x + " is not present in tree");
		}
	}
}

Output

A step-by-step explanation of the code

The code begins by declaring the necessary header files. The code begins by defining two classes, 'Node' and 'Binary tree'. The node contains three members: a data value and a pointer to the left and right child, whereas the binary tree comprises the tree's root.
The binary tree creates a getLevelUtil function which turns out to be a helper function. It has three parameters: node, data, and level.
The 'getLevel' function has two parameters node and data.
Now, we declare a 'newNode' function that helps us create a new node in the binary tree, and it usually takes a single parameter, data, and sets the left and right pointers to NILL.
In the program's primary function, the pointer 'root' is created to store the root of the binary tree.
The binary tree is built by assigning positions in the tree.
We create a for loop, which iterates over the values from 1 to 5. For each one of these values, the 'getLevel' function is called to find the level in the binary tree. In case the value is non-zero, the value will be present in the tree. Otherwise, a message indicating the value is not present in the tree is printed.
'getchar()' is used to wait for a character input before the program ends or terminates.
The program ends by returning the value 0 from the main function indicating the execution of the program.

Example 3)

# Writing a Python program that will help us in getting the node of a binary tree. 
class new__nod:

	# Creating a constructor that will create a new node
	def __init__(self, record):
		self.record = record
		self.Lft = None
		self.Rt = None

# Creating a helper function to help us get the binary tree's level. The level of the given data is already present in the tree; if not, we can return 0. 
def getLevelUtil(__nod, record, level):
	if (__nod == None):
		return 0

	if (__nod.record == record):
		return level

	downlevel = getLevelUtil(__nod.Lft,
							record, level + 1)
	if (downlevel != 0):
		return downlevel

	downlevel = getLevelUtil(__nod.Rt,
							record, level + 1)
	return downlevel
# We have to return the value of the given record 
def getLevel(__nod, record):

	return getLevelUtil(__nod, record, 1)
# Writing the main code to see the above approach
if __name__ == '__main__':

	# Let us construct the Tree shown
	# In the above figure
	root = new__nod(3)
	root.Lft = new__nod(2)
	root.Rt = new__nod(5)
	root.Lft.Lft = new__nod(1)
	root.Lft.Rt = new__nod(4)
	for x in range(1, 6):
		level = getLevel(root, x)
		if (level):
			print("Level of", x,
				"is", getLevel(root, x))
		else:
			print(x, "is not present in tree")

Output

A step-by-step explanation of the code

The code defines a class named 'newNode', which represents a node in the binary tree, a pointer to the left and right child, and a data value.
We will now create a getLevelUtil function which turns out to be a helper function. It has three parameters: node, data, and level.
The 'getLevel' function has two parameters node and data.
Now, we declare a 'newNode' function that helps us create a new node in the binary tree, and it usually takes a single parameter, data, and sets the left and right pointers to NILL.
In the program's primary function, the pointer 'root' is created to store the root of the binary tree.
The binary tree is built by assigning positions in the tree.
We create a for loop, which iterates over the values from 1 to 5. For each one of these values, the 'getLevel' function is called to find the level in the binary tree. If the value is non-zero, the value will be present in the tree. Otherwise, a message indicating the value is not present in the tree is printed.
'getchar()' is used to wait for a character input before the program ends or terminates.
The program ends by returning the value 0 from the primary function indicating the execution of the program.