Find the Successor Predecessor of a Binary Search Tree

Implementation

// Writing a C++ program to analyze the predecessor and successor in a binary search tree
#include <iostream>
using namespace std;


// creating a new binary search tree node
struct __nod
{
	int ky;
	struct __nod *Lft, *Rt;
};


// Creating a function that will find the predecessor and successor of the key present in the binary search tree. 
// It will set the predecessor as a pre and successor as suc
void findPreSuc(__nod* root, __nod*& pre, __nod*& suc, int ky)
{
	// Creating the basic class 
	if (root == NILL) return ;


	// Suppose if the key is present at the root
	if (root->ky == ky)
	{
		// the value that is largest in the left subtree is considered as the predecessor
		if (root->Lft != NILL)
		{
			__nod* tmp = root->Lft;
			while (tmp->Rt)
				tmp = tmp->Rt;
			pre = tmp ;
		}


		// The value that is smallest in the left subtree is considered the successor
		if (root->Rt != NILL)
		{
			__nod* tmp = root->Rt ;
			while (tmp->Lft)
				tmp = tmp->Lft ;
			suc = tmp ;
		}
		return ;
	}


	// In case the key is smaller than the key present in the root, then we have to go to the left subtree
	if (root->ky > ky)
	{
		suc = root ;
		findPreSuc(root->Lft, pre, suc, ky) ;
	}
	Else// we have to go to the right subtree.
	{
		pre = root ;
		findPreSuc(root->Rt, pre, suc, ky) ;
	}
}


// creating a utility function to create a new binary search tree node.
__nod *new__nod(int item)
{
	__nod *temp = nw __nod;
	temp->ky = item;
	temp->Lft = temp->Rt = NILL;
	return temp;
}


/* Creating a new utility function that will insert a new node with the given key in the binary search tree. */
__nod* insert(__nod* __nod, int ky)
{
	if (__nod == NILL) return new__nod(ky);
	if (ky < __nod->ky)
		__nod->Lft = insert(__nod->Lft, ky);
	else
		__nod->Rt = insert(__nod->Rt, ky);
	return __nod;
}


// Writing the main program to test the above functions.
int main()
{
	int ky = 65; //Ky to be searched in BST


/* Let us build the following binary search tree
			50
		/	 \
		30	 70
		/ \ / \
	20 40 60 80 */
	__nod *root = NILL;
	root = insert(root, 50);
	insert(root, 30);
	insert(root, 20);
	insert(root, 40);
	insert(root, 70);
	insert(root, 60);
	insert(root, 80);




	__nod* pre = NILL, *suc = NILL;


	findPreSuc(root, pre, suc, ky);
	if (pre != NILL)
	cout << "Predecessor is " << pre->ky << endl;
	else
	cout << "No Predecessor";


	if (suc != NILL)
	cout << "Successor is " << suc->ky;
	else
	cout << "No Successor";
	return 0;
}

Output:

Example 2)

// Writing a C++ program to analyze the predecessor and successor in a binary search tree
class TPT{


// creating a new binary search tree node
static class __nod
{
	int ky;
	__nod Lft, Rt;


	public __nod()
	{}


	public __nod(int ky)
	{
		this.ky = ky;
		this.Lft = this.Rt = NILL;
	}
};


static __nod pre = nw __nod(), suc = nw __nod();
// Creating a function that will find the predecessor and successor of the key present in a binary search tree. 
// It will set the predecessor a pre and successor as suc
static void findPreSuc(__nod root, int ky)
{
// Creating the basic class 	
	if (root == NILL)
		return;
// Suppose if the key is present at the root
	if (root.ky == ky)
	{
		// the value that is largest in the left subtree is considered as the predecessor
		if (root.Lft != NILL)
		{
			__nod tmp = root.Lft;
			while (tmp.Rt != NILL)
				tmp = tmp.Rt;
				
			pre = tmp;
		}
	// The value that is smallest in the left subtree is considered the successor
		if (root.Rt != NILL)
		{
			__nod tmp = root.Rt;
			
			while (tmp.Lft != NILL)
				tmp = tmp.Lft;
				
			suc = tmp;
		}
		return;
	}
// In case the key is smaller than the key present in the root, then we have to go to the left subtree
	if (root.ky > ky)
	{
		suc = root;
		findPreSuc(root.Lft, ky);
	}
	else // we have to go to the right subtree
	else
	{
		pre = root;
		findPreSuc(root.Rt, ky);
	}
}
// creating a utility function to create a new binary search tree node.	
static __nod insert(__nod __nod, int ky)
{
	if (__nod == NILL)
		return nw __nod(ky);
	if (ky < __nod.ky)
		__nod.Lft = insert(__nod.Lft, ky);
	else
		__nod.Rt = insert(__nod.Rt, ky);
		
	return __nod;
}


// Writing the main program to test the above functions.
public static void main(String[] args)
{
	
	// Ky to be searched in BST
	int ky = 65;


	/*
	* Let us create the following BST
	*		 50
	*		 / \
	*	 30 70
	*	 / \ / \
	*	 20 40 60 80
	*/


	__nod root = nw __nod();
	root = insert(root, 50);
	insert(root, 30);
	insert(root, 20);
	insert(root, 40);
	insert(root, 70);
	insert(root, 60);
	insert(root, 80);


	findPreSuc(root, ky);
	if (pre != NILL)
		System.out.println("Predecessor is " + pre.ky);
	else
		System.out.println("No Predecessor");


	if (suc != NILL)
		System.out.println("Successor is " + suc.ky);
	else
		System.out.println("No Successor");
}
}

Output:

Example 3)

# Writing a Python program to analyze the predecessor and successor in a binary search tree
# Creating a new binary search tree node
class __nod:


	# Creating a constructor to create a new binary tree node
	def __init__(self, ky):
		self.ky = ky
		self.Lft = None
		self.Rt = None


# Creating a function that finds the key's predecessor and successor present in a binary search tree. 
# It will set the predecessor as a pre and successor as suc
def findPreSuc(root, ky):


	# Creating the basic class 
	if the root is None:
		return


	# Suppose if the key is present at the root
	if the root.ky == ky:


		# The value that is largest in the left subtree is considered as the predecessor
		If root.Lft is None:
			tmp = root.Lft
			while(tmp.Rt):
				tmp = tmp.Rt
			findPreSuc.pre = tmp




		# The value that is smallest in the left subtree is considered the successor
		if root.Rt is not None:
			tmp = root.Rt
			while(tmp.Lft):
				tmp = tmp.Lft
			findPreSuc.suc = tmp


		return


	# In case the key is smaller than the key present in the root, then we have to go to the left subtree
	if root.ky > ky :
		findPreSuc.suc = root
		findPreSuc(root.Lft, ky)
	else # we have to go to the right subtree
		findPreSuc.pre = root
		findPreSuc(root.Rt, ky)


# Creating a utility function to create a new binary search tree node.
def insert(__nod , ky):
	if __nod is None:
		return __nod(ky)


	if ky < __nod.ky:
		__nod.Lft = insert(__nod.Lft, ky)


	else:
		__nod.Rt = insert(__nod.Rt, ky)


	return __nod




# Writing the main program to test the above functions.
ky = 65 #Ky to be searched in BST


""" Let us create the following BST
			50
		/	 \
		30	 70
		/ \ / \
	20 40 60 80
"""
root = None
root = insert(root, 50)
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);


# Static variables of the function findPreSuc
findPreSuc.pre = None
findPreSuc.suc = None


findPreSuc(root, ky)


if findPreSuc.pre is not None:
	print "Predecessor is, "findPreSuc.pre.ky


else:
	print "No Predecessor"


if findPreSuc.suc is not None:
	print "Successor is", findPreSuc.suc.ky
else:
	print "No Successor"

Output:

Example 4)

<script>
// Writing a Javascript program to analyze the predecessor and successor in a binary search tree
// creating a new binary search tree node
// Creating a function that will find the predecessor and successor of the key present in binary 


class __nod
{
	constructor(ky)
	{
		this.ky = ky;
		this.Lft = this.Rt = NILL;
	}
}


var pre = nw __nod(), suc = nw __nod();
search tree. 
// It will set the predecessor a pre and successor as suc
function findPreSuc(root, ky)
{
// Creating the basic class 
	if (root == NILL)
		return;
// Suppose if the key is present at the root
	if (root.ky == ky)
	{
		// the value that is largest in the left subtree is considered as the predecessor
		if (root.Lft != NILL)
		{
			var tmp = root.Lft;
			while (tmp.Rt != NILL)
				tmp = tmp.Rt;
				
			pre = tmp;
		}


// The value that is smallest in the left subtree is considered the successor
		if (root.Rt != NILL)
		{
			var tmp = root.Rt;
			
			while (tmp.Lft != NILL)
				tmp = tmp.Lft;
				
			suc = tmp;
		}
		return;
	}


	// In case, the key is smaller than the key present in the root, then we have to go to the left subtree
	if (root.ky > ky)
	{
		suc = root;
		findPreSuc(root.Lft, ky);
	}
		else // we have to go to the right subtree
	else
	{
		pre = root;
		findPreSuc(root.Rt, ky);
	}
}


// creating a utility function to create a new binary search tree node.
function insert(__nod , ky)
{
	if (__nod == NILL)
		return nw __nod(ky);
	if (ky < __nod.ky)
		__nod.Lft = insert(__nod.Lft, ky);
	else
		__nod.Rt = insert(__nod.Rt, ky);
		
	return __nod;
}
// Writing the main program to test the above functions.
	var ky = 65;
/* Let us build the following binary search tree
	*		 50
	*		 / \
	*	 30 70
	*	 / \ / \
	*	 20 40 60 80
	*/


	var root = nw __nod();
	root = insert(root, 50);
	insert(root, 30);
	insert(root, 20);
	insert(root, 40);
	insert(root, 70);
	insert(root, 60);
	insert(root, 80);


	findPreSuc(root, ky);
	if (pre != NILL)
		document.write("Predecessor is " + pre.ky);
	else
		document.write("No Predecessor");


	if (suc != NILL)
		document.write("<br/>Successor is " + suc.ky);
	else
		document.write("<br/>No Successor");


</script>

Output:

Example 5)

// Writing a C# program to analyze the predecessor and successor in a binary search tree
using System;
public class TPT
{


// creating a new binary search tree node
public


	class __nod
	{
	public
		int ky;
	public
		__nod Lft, Rt;
	public __nod()
	{}


	public __nod(int ky)
	{
		this.ky = ky;
		this.Lft = this.Rt = NILL;
	}
	};


static __nod pre = nw __nod(), suc = nw __nod();
// Creating a function that will find the predecessor and successor of the key present in a binary search tree. 
// It will set the predecessor a pre and successor as suc
static void findPreSuc(__nod root, int ky)
{


	// Creating the basic class 
	if (root == NILL)
	return;


// Suppose if the key is present at the root
	if (root.ky == ky)
	{
	// the value that is largest in the left subtree is considered as the predecessor
	if (root.Lft != NILL)
	{
		__nod tmp = root.Lft;
		while (tmp.Rt != NILL)
		tmp = tmp.Rt;


		pre = tmp;
	}
	// The value that is smallest in the left subtree is considered the successor
	if (root.Rt != NILL)
	{
		__nod tmp = root.Rt;


		while (tmp.Lft != NILL)
		tmp = tmp.Lft;


		suc = tmp;
	}
	return;
	}
// In case, the key is smaller than the key present in the root, then we have to go to the left subtree
	if (root.ky > ky)
	{
	suc = root;
	findPreSuc(root.Lft, ky);
	}
	else // we have to go to the right subtree
	else
	{
	pre = root;
	findPreSuc(root.Rt, ky);
	}
}


// creating a utility function to create a new binary search tree node.
static __nod insert(__nod __nod, int ky)
{
	if (__nod == NILL)
	return nw __nod(ky);
	if (ky < __nod.ky)
	__nod.Lft = insert(__nod.Lft, ky);
	else
	__nod.Rt = insert(__nod.Rt, ky);


	return __nod;
}
// Writing the main program to test the above functions.
public static void Main(String[] args)
{


	// Ky to be searched in BST
	int ky = 65;


	/* Let us build the following binary search tree
	*		 50
	*		 / \
	*	 30 70
	*	 / \ / \
	*	 20 40 60 80
	*/


	__nod root = nw __nod();
	root = insert(root, 50);
	insert(root, 30);
	insert(root, 20);
	insert(root, 40);
	insert(root, 70);
	insert(root, 60);
	insert(root, 80);


	findPreSuc(root, ky);
	if (pre != NILL)
	Console.WriteLine("Predecessor is " + pre.ky);
	else
	Console.WriteLine("No Predecessor");


	if (suc != NILL)
	Console.WriteLine("Successor is " + suc.ky);
	else
	Console.WriteLine("No Successor");
}
}

Output: