# 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:**