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

• Difficulty Level : Medium
• Last Updated : 27 May, 2021

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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

1. 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.
2. 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.
3. 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++

 `// C++ program to find predecessor``// and successor in a BST``#include ``using` `namespace` `std;` `// BST Node``struct` `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 predecessor.``            ``if` `(root->right) {``                ``suc = root->right;``                ``while` `(suc->left)``                    ``suc = suc->left;``            ``}` `            ``// the maximum value in left subtree``            ``// is successor.``            ``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 node``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 BST``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 program to test above function``int` `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

 `// Java program to find predecessor``// and successor in a BST``import` `java.util.*;``class` `GFG``{` `// BST Node``static` `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 node``static` `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 BST``static` `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 Code``public` `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

 `# Python3 program to find predecessor``# and successor in a BST` `# A utility function to create a``# new BST node``class` `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 BST``def` `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 Code``if` `__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#

 `// C# program to find predecessor``// and successor in a BST``using` `System;` `class` `GFG``{` `// BST Node``class` `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 node``static` `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 BST``static` `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 Code``public` `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`

## Javascript

 ``
Output:
```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/

My Personal Notes arrow_drop_up