Get the Level of a Given Key in a Binary Tree

The level of a key in a specific binary tree generally refers to the distance that is present between the root of the binary tree node and the node that is containing the desired key. It is very important and noteworthy how many steps are required to reach the desired key. Before we move further to the implementation details of the tree, let us carefully review the major concepts which are related to the binary tree.

This pattern will make sure that we have a solid foundation and understanding of the techniques that will help us in getting the level of a given key in the binary tree. Once we are familiar with all the interesting concepts and algorithms we can move forward and learn the examples that will help us understand the various algorithms, and code more effectively. They are very valuable when it comes to storing and managing data and processing the data.

We are given a binary tree and a key; with that, we have to write the level of the binary tree as well. Extracting the level of the binary tree can sometimes be cumbersome as it involves creating many different functions which carry their type of mechanism and, at last, provide the result.

Implementation

// Writing a C++ program that will help us in getting a level of nodes in a binary tree 
#include <bits/stdc++.h>
using namespace std;

/* Creating a tree with a node structure */
struct __nod {
	int record;
	struct __nod* Lft;
	struct __nod* Rt;
};
// Creating a helper function for the getLev() 
// This will help us get the returns for the level of the data present in the tree. 
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;
}

/* Now, we will return the level of the given data */
int getLevel(struct __nod* __nod, int record)
{
	return getLevelUtil(__nod, record, 1);
}

// Now, we will create a new utility function to help us create a new binary tree node. 
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 test the above functions
int main()
{
	struct __nod* root = new struct __nod;
	int x;

	//Building a new tree for the program
	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

Get the Level of a Given Key in a Binary Tree

A step-by-step explanation of the code

The code begins by declaring the necessary header files to help us carry out the input/output operations.
Next, in the program, we define a structure called 'Node' that contains three members: a data value and a pointer to the left and right child.
Next, we create a function called 'getlevelUtil', which is a helper function that helps find out the node level in the binary tree.
Within this function, the node first checks out the basic condition, whether the node is NULL or not; if not, it returns 0.
In case the current node's data matches up with the data value that we have been assigned, then it signifies that the node has been found, and the current level of that particular node is returned.
If, in case, the current node's data doesn't appear to be the same or match with it, the function calls itself, and that too with an incremented level, and the value is returned.
If the 'downlevel' value is non-zero, it signifies that the node was found in the left subtree, and if the value is still zero, then it signifies that the desired node was not found in the left subtree.
Finally, in this step function returns the value, which will either be the level of the node or 0 if it doesn't match.
The function 'newNode' is a new function that creates a new node that can store various new values and help in memory allocation.
In the primary function of the program, a binary tree is constructed.
Then a loop is executed from count 1 to 5.
The 'get level' function is called to print the level of the binary tree.

Example 2)

// Writing a C program that will help us get a level of nodes in a binary tree 
#include <stdio.h>
#include <stdlib.h>

/* Creating a tree with a node structure */
typedef struct __nod {
	int record;
	struct __nod* Lft;
	struct __nod* Rt;
} __nod;

// Creating a helper function for the getLev() 
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;
}

// This will help us get the returns for the level of the data present in the tree. 

int getLevel(__nod* __nod, int record)
{
	return getLevelUtil(__nod, record, 1);
}
/* Now, we will return the level of the given data */
__nod* new__nod(int record)
{
	__nod* temp = (__nod*)malloc(sizeof(__nod));
	temp->record = record;
	temp->Lft = NILL;
	temp->Rt = NILL;
	return temp;
}

// Now, we will create a new utility function to help us create a new binary tree node. 
int main()
{
	__nod* root;
	int x;

// writing the main code to test the above functions
	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)
			printf(" Level of %d is %d\n", x,
				getLevel(root, x));
		else
			printf(" %d is not present in tree \n", x);
	}

	getchar();
	return 0;
}

Output

A step-by-step explanation of the code

The code begins by declaring the necessary header files to help us carry out the input/output operations.
Next, in the program, we define a structure called 'typedef' that contains the following three members: a data value and a pointer to the left and right child.
Next, we create a function called 'getlevelUtil', which is a helper function that helps find out the node level in the binary tree.
Within this function, the node first checks out the basic condition, whether the node is NULL or not; if not, it returns 0.
In case the current node's data matches up with the data value that we have been assigned, then it signifies that the node has been found, and the current level of that particular node is returned.
If, in case, the current node's data doesn't appear to be the same or match with it, the function simply calls itself, and that too with an incremented level, and the value is returned.
If the 'downlevel' value is non-zero, it signifies that the node was found in the left subtree, and if the value is still zero, then it signifies that the desired node was not found in the left subtree.
Finally, in this step function returns the value, which will either be the level of the node or 0 if it doesn't match.
The function 'newNode' is a new function that creates a new node that can store various new values and help in memory allocation.
In the primary function of the program, a binary tree is constructed.
Then a loop is executed from count 1 to 5.
The 'get level' function is called to print the level of the binary tree.

Example 3)

// Writing a Java program that will help us in getting a level of nodes in a binary tree 
/* Creating a tree with 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 for the getLev() 
	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;
	}

// This will help us get the returns for the level of the data present in the tree. 
	int getLevel(__nod __nod, int record)
	{
		return getLevelUtil(__nod, record, 1);
	}

/* Now, we will return the level of the given data */
// writing the main code to test the above functions
	public static void main(String[] args)
	{
		BinaryTree tree = new BinaryTree();

			//Building a new tree for the program
		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 with a class named 'Node' and a class named 'Binary tree', which contains the program's root and main logic.
Next, in the program, we define a structure called 'Node' that contains three members: a data value and a pointer to the left and right child.
Next, we create a function called 'getlevelUtil', which is a helper function that helps find out the node level in the binary tree.
Within this function, the node first checks out the basic condition, whether the node is NULL or not; if not, it returns 0.
If the current node's data matches up with the data value that we have been assigned, it signifies that the node has been found and that the current level of that particular node is returned.
If, in case, the current node's data doesn't appear to be the same or match with it, the function simply calls itself, and that too with an incremented level, and the value is returned.
If the 'downlevel' value is non-zero, it signifies that the node was found in the left subtree, and if the value is still zero, then it signifies that the desired node was not found in the left subtree.
Finally, in this step function returns the value, which will either be the level of the node or 0 if it doesn't match.
The function 'newNode' is a new function that creates a new node that can store various new values and help in memory allocation.
In the primary function of the program, a binary tree is constructed.
Then a loop is executed from count 1 to 5.
The 'get level' function is called to print the level of the binary tree.