Inorder predecessor and successor for a given key in BST | Iterative Approach

27 Jan, 2022
Given a BST and a key. The task is to find the inorder successor and predecessor of the given key. In case, if either of predecessor or successor is not present, then print -1.Examples: 
Input:          50
               /  \
              /    \
            30     70
           / \     / \
          /   \   /   \
         20   40 60   80
            key = 65
Output: Predecessor : 60
        Successor : 70

Input:          50
               /  \
              /    \
            30     70
           / \     / \
          /   \   /   \
         20   40 60   80
            key = 100
Output: predecessor : 80
        successor : -1
Explanation: As no node in BST has key value greater 
than 100 so -1 is printed for successor.
In the previous post, a recursive solution has been discussed. The problem can be solved using an iterative approach. To solve the problem, the three cases while searching for the key has to be dealt with which are as described below: 
Root is the given key: In this case, if the left subtree is not NULL, then predecessor is the rightmost node in left subtree and if right subtree is not NULL, then successor is the leftmost node in right subtree.Root is greater than key: In this case, the key is present in left subtree of root. So search for the key in left subtree by setting root = root->left. Note that root could be an inorder successor of given key. In case the key has no right subtree, the root will be its successor.Root is less than key: In this case, key is present in right subtree of root. So search for the key in right subtree by setting root = root->right. Note that root could be an inorder predecessor of given key. In case the key has no left subtree, the root will be its predecessor.
Root is the given key: In this case, if the left subtree is not NULL, then predecessor is the rightmost node in left subtree and if right subtree is not NULL, then successor is the leftmost node in right subtree.
Root is greater than key: In this case, the key is present in left subtree of root. So search for the key in left subtree by setting root = root->left. Note that root could be an inorder successor of given key. In case the key has no right subtree, the root will be its successor.
Root is less than key: In this case, key is present in right subtree of root. So search for the key in right subtree by setting root = root->right. Note that root could be an inorder predecessor of given key. In case the key has no left subtree, the root will be its predecessor.
Below is the implementation of above approach:  
C++
Java
Python3
C#
Javascript
// C++ program to find predecessor// and successor in a BST#include <bits/stdc++.h>using namespace std; // BST Nodestruct Node {    int key;    struct Node *left, *right;}; // Function that finds predecessor and successor of key in BST.void findPreSuc(Node* root, Node*& pre, Node*& suc, int key){    if (root == NULL)        return;     // Search for given key in BST.    while (root != NULL) {         // If root is given key.        if (root->key == key) {             // the minimum value in right subtree            // is successor.            if (root->right) {                suc = root->right;                while (suc->left)                    suc = suc->left;            }             // the maximum value in left subtree            // is predecessor.            if (root->left) {                pre = root->left;                while (pre->right)                    pre = pre->right;            }             return;        }         // If key is greater than root, then        // key lies in right subtree. Root        // could be predecessor if left        // subtree of key is null.        else if (root->key < key) {            pre = root;            root = root->right;        }         // If key is smaller than root, then        // key lies in left subtree. Root        // could be successor if right        // subtree of key is null.        else {            suc = root;            root = root->left;        }    }} // A utility function to create a new BST nodeNode* newNode(int item){    Node* temp = new Node;    temp->key = item;    temp->left = temp->right = NULL;    return temp;} // A utility function to insert// a new node with given key in BSTNode* insert(Node* node, int key){    if (node == NULL)        return newNode(key);    if (key < node->key)        node->left = insert(node->left, key);    else        node->right = insert(node->right, key);    return node;} // Driver program to test above functionint main(){    int key = 65; // Key to be searched in BST     /* Let us create following BST                 50                /  \               /    \              30     70             / \     / \            /   \   /   \           20   40 60   80*/    Node* root = NULL;    root = insert(root, 50);    insert(root, 30);    insert(root, 20);    insert(root, 40);    insert(root, 70);    insert(root, 60);    insert(root, 80);     Node *pre = NULL, *suc = NULL;     findPreSuc(root, pre, suc, key);    if (pre != NULL)        cout << "Predecessor is " << pre->key << endl;    else        cout << "-1";     if (suc != NULL)        cout << "Successor is " << suc->key;    else        cout << "-1";    return 0;}
// Java program to find predecessor// and successor in a BSTimport java.util.*;class GFG{ // BST Nodestatic class Node{    int key;    Node left, right;};static Node pre;static Node suc; // Function that finds predecessor// and successor of key in BST.static void findPreSuc(Node root, int key){    if (root == null)        return;     // Search for given key in BST.    while (root != null)    {         // If root is given key.        if (root.key == key)        {             // the minimum value in right subtree            // is successor.            if (root.right != null)            {                suc = root.right;                while (suc.left != null)                    suc = suc.left;            }             // the maximum value in left subtree            // is predecessor.            if (root.left != null)            {                pre = root.left;                while (pre.right != null)                    pre = pre.right;            }            return;        }         // If key is greater than root, then        // key lies in right subtree. Root        // could be predecessor if left        // subtree of key is null.        else if (root.key < key)        {            pre = root;            root = root.right;        }         // If key is smaller than root, then        // key lies in left subtree. Root        // could be successor if right        // subtree of key is null.        else        {            suc = root;            root = root.left;        }    }} // A utility function to create a new BST nodestatic Node newNode(int item){    Node temp = new Node();    temp.key = item;    temp.left = temp.right = null;    return temp;} // A utility function to insert// a new node with given key in BSTstatic Node insert(Node node, int key){    if (node == null)        return newNode(key);    if (key < node.key)        node.left = insert(node.left, key);    else        node.right = insert(node.right, key);    return node;} // Driver Codepublic static void main(String[] args){    int key = 65; // Key to be searched in BST     /* Let us create following BST                50                / \            / \            30     70            / \     / \            / \ / \        20 40 60 80    */    Node root = null;    root = insert(root, 50);    insert(root, 30);    insert(root, 20);    insert(root, 40);    insert(root, 70);    insert(root, 60);    insert(root, 80);     findPreSuc(root, key);    if (pre != null)        System.out.println("Predecessor is " +                                     pre.key);    else        System.out.print("-1");     if (suc != null)        System.out.print("Successor is " + suc.key);    else        System.out.print("-1");    }} // This code is contributed by Princi Singh
# Python3 program to find predecessor# and successor in a BST # A utility function to create a# new BST nodeclass newNode:         # Constructor to create a new node    def __init__(self, data):        self.key = data        self.left = None        self.right = None         # Function that finds predecessor and# successor of key in BST.def findPreSuc(root, pre, suc, key):    if root == None:        return     # Search for given key in BST.    while root != None:         # If root is given key.        if root.key == key:             # the minimum value in right            # subtree is predecessor.            if root.right:                suc[0] = root.right                while suc[0].left:                    suc[0] = suc[0].left             # the maximum value in left            # subtree is successor.            if root.left:                pre[0] = root.left                while pre[0].right:                    pre[0] = pre[0].right             return         # If key is greater than root, then        # key lies in right subtree. Root        # could be predecessor if left        # subtree of key is null.        elif root.key < key:            pre[0] = root            root = root.right         # If key is smaller than root, then        # key lies in left subtree. Root        # could be successor if right        # subtree of key is null.        else:            suc[0] = root            root = root.left # A utility function to insert# a new node with given key in BSTdef insert(node, key):    if node == None:        return newNode(key)    if key < node.key:        node.left = insert(node.left, key)    else:        node.right = insert(node.right, key)    return node # Driver Codeif __name__ == '__main__':    key = 65 # Key to be searched in BST     # Let us create 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)     pre, suc = [None], [None]     findPreSuc(root, pre, suc, key)    if pre[0] != None:        print("Predecessor is", pre[0].key)    else:        print("-1")     if suc[0] != None:        print("Successor is", suc[0].key)    else:        print("-1") # This code is contributed by PranchalK
// C# program to find predecessor// and successor in a BSTusing System; class GFG{ // BST Nodeclass Node{    public int key;    public Node left, right;};static Node pre;static Node suc; // Function that finds predecessor// and successor of key in BST.static void findPreSuc(Node root, int key){    if (root == null)        return;     // Search for given key in BST.    while (root != null)    {         // If root is given key.        if (root.key == key)        {             // the minimum value in right subtree            // is predecessor.            if (root.right != null)            {                suc = root.right;                while (suc.left != null)                    suc = suc.left;            }             // the maximum value in left subtree            // is successor.            if (root.left != null)            {                pre = root.left;                while (pre.right != null)                    pre = pre.right;            }            return;        }         // If key is greater than root, then        // key lies in right subtree. Root        // could be predecessor if left        // subtree of key is null.        else if (root.key < key)        {            pre = root;            root = root.right;        }         // If key is smaller than root, then        // key lies in left subtree. Root        // could be successor if right        // subtree of key is null.        else        {            suc = root;            root = root.left;        }    }} // A utility function to create a new BST nodestatic Node newNode(int item){    Node temp = new Node();    temp.key = item;    temp.left = temp.right = null;    return temp;} // A utility function to insert// a new node with given key in BSTstatic Node insert(Node node, int key){    if (node == null)        return newNode(key);    if (key < node.key)        node.left = insert(node.left, key);    else        node.right = insert(node.right, key);    return node;} // Driver Codepublic static void Main(String[] args){    int key = 65; // Key to be searched in BST     /* Let us create following BST                50                / \            / \            30     70            / \     / \            / \ / \        20 40 60 80    */    Node root = null;    root = insert(root, 50);    insert(root, 30);    insert(root, 20);    insert(root, 40);    insert(root, 70);    insert(root, 60);    insert(root, 80);     findPreSuc(root, key);    if (pre != null)        Console.WriteLine("Predecessor is " +                                    pre.key);    else        Console.Write("-1");     if (suc != null)        Console.Write("Successor is " + suc.key);    else        Console.Write("-1");    }} // This code is contributed by PrinciRaj1992
<script> // JavaScript program to find predecessor// and successor in a BST    // BST Nodeclass Node {    constructor(val) {        this.key = val;        this.left = null;        this.right = null;    }}var pre;var suc; // Function that finds predecessor// and successor of key in BST.function findPreSuc(root , key){    if (root == null)        return;     // Search for given key in BST.    while (root != null)    {         // If root is given key.        if (root.key == key)        {             // the minimum value in right subtree            // is successor.            if (root.right != null)            {                suc = root.right;                while (suc.left != null)                    suc = suc.left;            }             // the maximum value in left subtree            // is predecessor.            if (root.left != null)            {                pre = root.left;                while (pre.right != null)                    pre = pre.right;            }            return;        }         // If key is greater than root, then        // key lies in right subtree. Root        // could be predecessor if left        // subtree of key is null.        else if (root.key < key)        {            pre = root;            root = root.right;        }         // If key is smaller than root, then        // key lies in left subtree. Root        // could be successor if right        // subtree of key is null.        else        {            suc = root;            root = root.left;        }    }} // A utility function to create a new BST nodefunction newNode(item){    var temp = new Node();    temp.key = item;    temp.left = temp.right = null;    return temp;} // A utility function to insert// a new node with given key in BSTfunction insert(node , key){    if (node == null)        return newNode(key);    if (key < node.key)        node.left = insert(node.left, key);    else        node.right = insert(node.right, key);    return node;} // Driver Code      var key = 65; // Key to be searched in BST     /* Let us create following BST                50                / \            / \            30     70            / \     / \            / \ / \        20 40 60 80    */    var root = null;    root = insert(root, 50);    insert(root, 30);    insert(root, 20);    insert(root, 40);    insert(root, 70);    insert(root, 60);    insert(root, 80);     findPreSuc(root, key);    if (pre != null)        document.write("Predecessor is " +                                     pre.key+"<br/>");    else        document.write("-1<br/>");     if (suc != null)        document.write("Successor is " + suc.key);    else        document.write("-1"); // This code contributed by gauravrajput1 </script>
Predecessor is 60
Successor is 70
 
Time Complexity: O(N) Auxiliary Space: O(1)Related Article: https://www.geeksforgeeks.org/inorder-predecessor-successor-given-key-bst/
PranchalKatiyar
princi singh
princiraj1992
shoryagoswami
GauravRajput1
sandip92809mandal
BST
Traversal
Binary Search Tree
Data Structures
Data Structures
Traversal
Binary Search Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
A program to check if a binary tree is BST or not
Find postorder traversal of BST from preorder traversal
Overview of Data Structures | Set 2 (Binary Tree, BST, Heap and Hash)
Optimal Binary Search Tree | DP-24
Sorted Array to Balanced BST
DSA Sheet by Love Babbar
SDE SHEET - A Complete Guide for SDE Preparation
Top 50 Array Coding Problems for Interviews
Introduction to Data Structures
Doubly Linked List | Set 1 (Introduction and Insertion)