Find the In-Order Successor of a Node in a Binary Tree

Binary search trees have proven to be vigorous data structures for storing and retrieving elements in the tree. The trees are generally responsible for offering and donating an organized way of nodes and the way in which they will be arranged. This makes them very fit and reliable when it comes to performing various other tasks, such as searching in an ordered set of lists and several other operations. Among the various other operations that a binary search tree can efficiently perform, one such task is determining the in-order successor of the binary tree.

Some advantages of finding the inorder successor of binary search tree are:-

It makes the search operation and various other operations significantly easier, and also we can easily find out the time complexity in this.
Implementing the iterators becomes very efficient as when we know the inorder successor; it becomes effortless to move forward to keep track of the functionalities, such as keeping track of the iterators.
It is also beneficial when it comes to deletion and replacement because when we are deleting a node in the binary tree and we have to perform the in-order successor, we can easily use that to replace the gap after the deletion.

Implementation

#include <iostream>
using namespace std;

/* A BST typically consists of a data value and a pointer to the left and right child. */
struct _nod {
	int record;
	struct _nod* lft;
	struct _nod* rt;
	struct _nod* parr;
};

struct _nod* minValue(struct _nod* _nod);

struct _nod* inOrderSuccessor(
	struct _nod* root,
	struct _nod* n)
{
	//This is step 1 of the algorithm
	if (n->rt != NULL)
		return minValue(n->rt);

//Second step of the algorithm
	struct _nod* p = n->parr;
	while (p != NULL && n == p->rt) {
		n = p;
		p = p->parr;
	}
	return p;
}

/* we are given a non-empty BST, and from that, we don't have to search an entire tree. */
struct _nod* minValue(struct _nod* _nod)
{
	struct _nod* current = _nod;

	/* travel down to find out the leftmost leaf in the tree*/
	while (current->lft != NULL) {
		current = current->lft;
	}
	return current;
}

/* creating a helper function will help us allocate a new node with some values and NULL pointers to the left and right child. */
struct _nod* new_nod(int record)
{
	struct _nod* _nod = (struct _nod*)
		malloc(sizeof(
			struct _nod));
	_nod->record = record;
	_nod->lft = NULL;
	_nod->rt = NULL;
	_nod->parr = NULL;

	return (_nod);
}

struct _nod* insert(struct _nod* _nod,
	int record)
{
	/* 1. In case the tree turns out to be vacant, we have to create a new node.*/
	if (_nod == NULL)
		return (new_nod(record));
	else {
		struct _nod* temp;

		/* 2. Else, we have to move down the tree*/
		if (record <= _nod->record) {
			temp = insert(_nod->lft, record);
			_nod->lft = temp;
			temp->parr = _nod;
		}
		else {
			temp = insert(_nod->rt, record);
			_nod->rt = temp;
			temp->parr = _nod;
		}

		/* we have to return the node pointer*/
		return _nod;
	}
}

/* Driver program to test above functions*/
int main()
{
	struct _nod *root = NULL, *temp, *succ, *min;

	root = insert(root, 20);
	root = insert(root, 8);
	root = insert(root, 22);
	root = insert(root, 4);
	root = insert(root, 12);
	root = insert(root, 10);
	root = insert(root, 14);
	temp = root->lft->rt->rt;

	succ = inorder successor(root, temp);
	if (success != NULL)
		cout << "\n Inorder Successor of " << temp->record<< " is "<< succ->record;
	else
		cout <<"\n Inorder Successor doesn't exit";

	getchar();
	return 0;
}

Output:

Find the In-Order Successor of a Node in a Binary Tree

A step-by-step explanation of the code

The code begins by including all the necessary header files to carry out the program's various input and output operations.
A structure 'node' is defined that will represent the nodes in a binary tree. A node has three parameters that are data and a pointer to the left and right child.
The code will specifically return two function types: one is struct node minValue(struct node* node), and another one is struct node* inOrderSuccessor(struct node* root, struct node* n).
The minValue function will help us take the node pointer as input and traverse the whole tree until it reaches the leftmost node in the left subtree, which will have the minimum value.
Now, we will consider the in-order successor function in which we take the root node and node n for which we perform the in-order traversal.
Next, we define a 'newNode' function to help us allocate memory to the new node and store value in the tree.
The 'insert' function will help us to insert a node.
The primary function is the entry point of any program, and it creates a binary tree in it.
Finally, the program ends with a call to the 'getChar()' function that will wait for input as a character and returns 0 to indicate the successful execution of the program.

Example 2)

//Writing a Java program to find the minimum value in the binary tree

// creating a binary tree node
class _nod {

	int record;
	_nod lft, rt, parr;

	_nod(int d)
	{
		record = d;
		lft = rt = parr = NULL;
	}
}

class BinaryTree {

	static _nod head;

/* we are given a non-empty BST, and from that, we don't have to search an entire tree. */
	_nod insert(_nod _nod, int record)
	{

	/* 1. In case the tree turns out to be vacant, we have to create a new node.*/
		if (_nod == NULL) {
			return (new _nod(record));
		}
		else {

			_nod temp = NULL;

		/* 2. Else, we have to move down the tree*/
			if (record <= _nod.record) {
				temp = insert(_nod.lft, record);
				_nod.lft = temp;
				temp.parr = _nod;
			}
			else {
				temp = insert(_nod.rt, record);
				_nod.rt = temp;
				temp.parr = _nod;
			}

		/* we have to return the node pointer*/
			return _nod;
		}
	}

	_nod inOrderSuccessor(_nod root, _nod n)
	{

	//This is step 1 of the algorithm
		if (n.rt != NULL) {
			return minValue(n.rt);
		}

//Second step of the algorithm
		_nod p = n.parr;
		while (p != NULL && n == p.rt) {
			n = p;
			p = p.parr;
		}
		return p;
	}

v	_nod minValue(_nod _nod)
	{
		_nod current = _nod;

	/* travel down to find out the leftmost leaf in the tree*/
		while (current.lft != NULL) {
			current = current.lft;
		}
		return current;
	}

	// Main program
	public static void main(String[] args)
	{
		BinaryTree tree = new BinaryTree();
		_nod root = NULL, temp = NULL, suc = NULL, min = NULL;
		root = tree.insert(root, 20);
		root = tree.insert(root, 8);
		root = tree.insert(root, 22);
		root = tree.insert(root, 4);
		root = tree.insert(root, 12);
		root = tree.insert(root, 10);
		root = tree.insert(root, 14);
		temp = root.lft.rt.rt;
		suc = tree.inOrderSuccessor(root, temp);
		if (suc != NULL) {
			System.out.println(
				"Inorder successor of "
				+ temp.record + " is " + suc.record);
		}
		else {
			System.out.println(
				"In order successor does not exist");
		}
	}
}

Output:

A step-by-step explanation of the code

The code begins by importing the necessary Java packages.
A class is defined as named 'Binary Tree', which holds the main logic of the program for inserting nodes in the tree and finding out the minimum value.
A structure 'node' is defined that will represent the nodes in a binary tree. It comprises a data value and a pointer to the left and right child.
The code will specifically return two function types: one is struct node minValue(struct node* node), and another one is struct node* inOrderSuccessor(struct node* root, struct node* n).
The minValue function will help us take the node pointer as input and traverse the whole tree until it reaches the leftmost node in the left subtree, which will have the minimum value.
Now, we will consider the inorder successor function in which we take the root node and node n for which we perform the inorder traversal.
Next, we define a 'newNode' function to help us allocate memory to the new node and store value in the tree.
The 'insert' function will help us to insert a node.
The primary function is the entry point of any program, and it creates a binary tree in it.
Finally, the program ends with a call to the 'getChar()' function that will wait for input as a character and returns 0 to indicate the successful execution of the program.