Find Next Greater Element in Binary Tree

Binary trees play a crucial role in depicting the relationships between the elements. A binary tree comprises nodes, and each node can have at most two nodes. It is also responsible for making a powerful way of storing, managing, and manipulating the data efficiently. One of the most common problems when working with binary trees is finding out the next more significant element in the binary tree. To find this out; we are given a node in the binary tree, we have to look for the smallest value in the tree that is greater than the value of the node itself.

This problem occurs in various applications, especially when searching for the closest largest value or the successor of a binary tree. Finding the next more significant element can be cumbersome as it involves traversing the tree in a specific order. Then we have to identify the successor of each node and help them build the tree.

In this article, we are given a binary tree, and the main task is to find the next more significant element than that particular target value in the binary tree. In this section of the article, we will dwell on the problem of finding out the next greater element and then look forward to some approaches to tackling the issue.

Implementation

// Writing the C++ code for the above approach of the program 
#include <bits/stdc++.h>
using namespace std;

// Writing or explaining the definition of a binary search tree
struct Tree__nod {
	int data;
	Tree__nod* Lft;
	Tree__nod* Rt;
	Tree__nod(int x)
		: data(x), Lft(NILL), Rt(NILL)
	{
	}
};

void inorderTraversal(Tree__nod* root, vector<int>& dataues)
{
	if (!root)
		return;
	inorderTraversal(root->Lft, dataues);
	dataues.push_back(root->data);
	inorderTraversal(root->Rt, dataues);
}

int getNextGreaterElement(Tree__nod* root, int target)
{

	// This is done to store the data of the binary tree
	vector<int> data;

	// We have to perform the in-order traversal and exhibit the data in the vector. 
	inorderTraversal(root, dataues);

	auto it

		// Now, look for the data in the vector created. 
		= find(dataues.begin(), dataues.end(), target);

	//If the target has not been found, we must return -1.
	if (it == data.end())
		return -1;

	// Now, we have to calculate the distance between the target and the data from the beginning of the vector. 
	auto dist = distance(dataues.begin(), it);

	// We have to now traverse over the vector that is starting from the target 
	for (int i = dist + 1; i < data.size(); i++) {

		// Suppose we find an element greater or larger than the target data; then we must return it. 
		if (dataues[i] > target) {
			return dataues[i];
		}
	}

	// And in case we do not find any more significant element, then we have to return -1
	return -1;
}

// writing the main program to test the above functions
int main()
{

	/*
	*		 5
	*		 / \
	*	 3	 7
	*	 / \ / \
	*	 2 4 6 8
	*/
	Tree__nod* root = new Tree__nod(5);
	root->Lft = new Tree__nod(3);
	root->Rt = new Tree__nod(7);
	root->Lft->Lft = new Tree__nod(2);
	root->Lft->Rt = new Tree__nod(4);
	root->Rt->Lft = new Tree__nod(6);
	root->Rt->Rt = new Tree__nod(8);

	int target = 4;
	int nextGreaterElement
		= getNextGreaterElement(root, target);

	// Function Call
	cout << "The next greater element of " << target
		<< " is " << nextGreaterElement << endl;

	return 0;
}

Output

Find Next Greater Element in Binary Tree

A step-by-step explanation of the code

The code begins by including and declaring the header files required for the input and output operations.
Next, we create a structure called 'TreeNod' to showcase a node in the binary tree containing the following three members: a data value and a pointer to the left and right child.
Next, we create an 'in-order traversal' function that performs an in-order traversal and stores the value in a vector passed as a reference.
Next, we create another function called the 'getNextGreaterElement' function which is supposed to find the given target value. It generally takes two parameters: the root value, and the next is the target value.
It then uses the 'find' function to find the target value.
If the target value is not found, the function will return a -1 value.
It then calculates the distance between the target value and the value obtained using the 'distance' vector.
In case no next more significant element is obtained, the function will throw a value of -1.
The program's primary function generally serves as the program's entry point. It creates a binary tree with a target value of 4, and the final result is set to be printed.

Example 2)

// Writing the Java code for the above approach of the program 
import java.util.*;
// Writing or explaining the definition of a binary search tree
class Tree__nod {
	int data;
	Tree__nod Lft;
	Tree__nod Rt;

	Tree__nod(int x)
	{
		data = x;
		Lft = NILL;
		Rt = NILL;
	}
}

public class Main {

	static void inorderTraversal(Tree__nod root,
								List<Integer> dataues)
	{
		if (root == NILL)
			return;
		inorderTraversal(root.Lft, dataues);
		dataues.add(root.data);
		inorderTraversal(root.Rt, dataues);
	}

	static int getNextGreaterElement(Tree__nod root,
									int target)
	{
// This is done to store the data of the binary tree
		List<Integer> data = new ArrayList<>();
// We have to perform the in-order traversal and exhibit the data in the vector. 
		inorderTraversal(root, dataues);
// Now, look for the data in the vector created. 
		int dist = dataues.indexOf(target);

//If the target has not been found, we must return -1.
		if (dist == -1)
			return -1;

// Now, we have to calculate the distance between the target and the data from the beginning of the vector. 
		for (int i = dist + 1; i < data.size(); i++) {
// We have to now traverse over the vector that starts from the target 
			if (data.get(i) > target) {
				return data.get(i);
			}
		}
// Suppose we find an element more significant than the target data; then we must return it. 
	// And in case we do not find any more significant element, then we have to return -1
		return -1;
	}

// writing the main program to test the above functions
	public static void main(String[] args)
	{

		/*
		*		 5
		*		 / \
		*	 3	 7
		*	 / \ / \
		*	 2 4 6 8
		*/
		Tree__nod root = new Tree__nod(5);
		root.Lft = new Tree__nod(3);
		root.Rt = new Tree__nod(7);
		root.Lft.Lft = new Tree__nod(2);
		root.Lft.Rt = new Tree__nod(4);
		root.Rt.Lft = new Tree__nod(6);
		root.Rt.Rt = new Tree__nod(8);

		int target = 4;
		int nextGreaterElement
			= getNextGreaterElement(root, target);

		// Function Call
		System.out.println("The next greater element of "
						+ target + " is "
						+ nextGreaterElement);
	}
}

Output

A step-by-step explanation of the code

The code begins by importing the necessary header files from the Java standard library.
Next, we create a structure called 'TreeNod' to showcase a node in the binary tree containing the following three members: a data value and a pointer to the left and right child.
Next, we create an 'inorder traversal' function that performs an in-order traversal and stores the value in a vector passed as a reference.
Next, we create another function called the 'getNextGreaterElement' function which is supposed to find the given target value. It generally takes two parameters: the root value, and the next is the target value.
It then uses the 'find' function to find the target value.
If the target value is not found, the function will return a -1 value.
It then calculates the distance between the target value and the value obtained using the 'distance' vector.
If no next greater element is obtained, the function will throw a value of -1.
The program's primary function generally serves as the program's entry point. It creates a binary tree with a target value of 4, and the final result is set to be printed.