Inorder predecessor in Binary Search Tree
Last Updated :
23 Jul, 2025
Given a Binary Search Tree, the task is to find the In-Order predecessor of a given target key.
In a Binary Search Tree (BST), the Inorder predecessor of a node is the previous node in the Inorder traversal of the BST. The Inorder predecessor is NULL for the first node in the Inorder traversal.
Examples:
In the below diagram, inorder predecessor of 8 is 4, inorder predecessor of 10 is 8 and inorder predecessor of 14 is 12.
We have discussed different methods for Inorder predecessor in Binary Tree. These methods either work in O(n) time or expect parent pointer/reference to be present in every node. We can use Binary Search Tree properties to efficiently find the successor in O(h) time.
Approach:
We follow the idea of normal BST Search. In BST search, we get closer to the key by comparing with the current node. So the last lesser key visited during search is the predecessor.
Step by step approach:
- Initialize current node to root and predecessor to NULL.
- If current node is NULL, return NULL (no predecessor exists).
- If target > current node value, current node is potential predecessor - update predecessor and move right.
- If target < current node value, move left.
- If target equals current node value and left subtree exists, return rightmost node in left subtree.
- If target equals current node value and no left subtree, break (predecessor already found).
Below is the implementation of the above approach:
C++
// C++ Program to find Inorder Successor in
// Binary Search Tree
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
int data;
Node* left;
Node* right;
Node(int x) {
data = x;
left = nullptr;
right = nullptr;
}
};
// Function to find the rightmost (maximum)
// node in the left subtree
Node* rightmost(Node* node) {
while (node->right != nullptr) {
node = node->right;
}
return node;
}
Node* getPred(Node* root, int target) {
// No Inorder predecessor
if (root == nullptr) return nullptr;
// Use BST properties to search for the
// target and predecessor
Node* pred = nullptr;
Node* curr = root;
while (curr != nullptr) {
// If the current node's data is less than the target,
// it is a potential predecessor
if (target > curr->data) {
pred = curr;
curr = curr->right;
}
// If greater, move to the left child
else if (target < curr->data) {
curr = curr->left;
}
// If equal
else {
// If the left subtree of target node exists
// then predecessor will be right most node
// of the left subtree.
if (curr->left != nullptr) {
return rightmost(curr->left);
}
// Otherwise, the predecessor has already
// been stored in the pred variable
break;
}
}
return pred;
}
int main() {
// Construct a BST
// 20
// / \
// 8 22
// / \
// 4 12
// / \
// 10 14
Node *root = new Node(20);
root->left = new Node(8);
root->right = new Node(22);
root->left->left = new Node(4);
root->left->right = new Node(12);
root->left->right->left = new Node(10);
root->left->right->right = new Node(14);
int target = 12;
Node* pred = getPred(root, target);
if (pred != nullptr)
cout << pred->data;
else
cout << "null";
return 0;
}
// C Program to find Inorder Successor in
// Binary Search Tree
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* left;
struct Node* right;
};
// Function to find the rightmost (maximum)
// node in the left subtree
struct Node* rightmost(struct Node* node) {
while (node->right != NULL) {
node = node->right;
}
return node;
}
struct Node* getPred(struct Node* root, int target) {
// No Inorder predecessor
if (root == NULL) return NULL;
// Use BST properties to search for the
// target and predecessor
struct Node* pred = NULL;
struct Node* curr = root;
while (curr != NULL) {
// If the current node's data is less than the target,
// it is a potential predecessor
if (target > curr->data) {
pred = curr;
curr = curr->right;
}
// If greater, move to the left child
else if (target < curr->data) {
curr = curr->left;
}
// If equal
else {
// If the left subtree of target node exists
// then predecessor will be right most node
// of the left subtree.
if (curr->left != NULL) {
return rightmost(curr->left);
}
// Otherwise, the predecessor has already
// been stored in the pred variable
break;
}
}
return pred;
}
struct Node* createNode(int x) {
struct Node* newNode =
(struct Node*)malloc(sizeof(struct Node));
newNode->data = x;
newNode->left = NULL;
newNode->right = NULL;
return newNode;
}
int main() {
// Construct a BST
struct Node *root = createNode(20);
root->left = createNode(8);
root->right = createNode(22);
root->left->left = createNode(4);
root->left->right = createNode(12);
root->left->right->left = createNode(10);
root->left->right->right = createNode(14);
int target = 12;
struct Node* pred = getPred(root, target);
if (pred != NULL)
printf("%d", pred->data);
else
printf("null");
return 0;
}
// Java Program to find Inorder Successor in
// Binary Search Tree
class Node {
int data;
Node left, right;
Node(int x) {
data = x;
left = null;
right = null;
}
}
class GfG {
// Function to find the rightmost (maximum)
// node in the left subtree
static Node rightmost(Node node) {
while (node.right != null) {
node = node.right;
}
return node;
}
static Node getPred(Node root, int target) {
// No Inorder predecessor
if (root == null) return null;
// Use BST properties to search for the
// target and predecessor
Node pred = null;
Node curr = root;
while (curr != null) {
// If the current node's data is less than the target,
// it is a potential predecessor
if (target > curr.data) {
pred = curr;
curr = curr.right;
}
// If greater, move to the left child
else if (target < curr.data) {
curr = curr.left;
}
// If equal
else {
// If the left subtree of target node exists
// then predecessor will be right most node
// of the left subtree.
if (curr.left != null) {
return rightmost(curr.left);
}
// Otherwise, the predecessor has already
// been stored in the pred variable
break;
}
}
return pred;
}
public static void main(String[] args) {
// Construct a BST
Node root = new Node(20);
root.left = new Node(8);
root.right = new Node(22);
root.left.left = new Node(4);
root.left.right = new Node(12);
root.left.right.left = new Node(10);
root.left.right.right = new Node(14);
int target = 12;
Node pred = getPred(root, target);
if (pred != null)
System.out.print(pred.data);
else
System.out.print("null");
}
}
# Python Program to find Inorder Successor in
# Binary Search Tree
class Node:
def __init__(self, x):
self.data = x
self.left = None
self.right = None
# Function to find the rightmost (maximum)
# node in the left subtree
def rightmost(node):
while node.right is not None:
node = node.right
return node
def getPred(root, target):
# No Inorder predecessor
if root is None:
return None
# Use BST properties to search for the
# target and predecessor
pred = None
curr = root
while curr is not None:
# If the current node's data is less than the target,
# it is a potential predecessor
if target > curr.data:
pred = curr
curr = curr.right
# If greater, move to the left child
elif target < curr.data:
curr = curr.left
# If equal
else:
# If the left subtree of target node exists
# then predecessor will be right most node
# of the left subtree.
if curr.left is not None:
return rightmost(curr.left)
# Otherwise, the predecessor has already
# been stored in the pred variable
break
return pred
if __name__ == "__main__":
# Construct a BST
root = Node(20)
root.left = Node(8)
root.right = Node(22)
root.left.left = Node(4)
root.left.right = Node(12)
root.left.right.left = Node(10)
root.left.right.right = Node(14)
target = 12
pred = getPred(root, target)
if pred is not None:
print(pred.data)
else:
print("null")
// C# Program to find Inorder Successor in
// Binary Search Tree
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left, right;
public Node(int x) {
data = x;
left = null;
right = null;
}
}
class GfG {
// Function to find the rightmost (maximum)
// node in the left subtree
static Node rightmost(Node node) {
while (node.right != null) {
node = node.right;
}
return node;
}
static Node getPred(Node root, int target) {
// No Inorder predecessor
if (root == null) return null;
// Use BST properties to search for the
// target and predecessor
Node pred = null;
Node curr = root;
while (curr != null) {
// If the current node's data is less than the target,
// it is a potential predecessor
if (target > curr.data) {
pred = curr;
curr = curr.right;
}
// If greater, move to the left child
else if (target < curr.data) {
curr = curr.left;
}
// If equal
else {
// If the left subtree of target node exists
// then predecessor will be right most node
// of the left subtree.
if (curr.left != null) {
return rightmost(curr.left);
}
// Otherwise, the predecessor has already
// been stored in the pred variable
break;
}
}
return pred;
}
static void Main() {
// Construct a BST
// 20
// / \
// 8 22
// / \
// 4 12
// / \
// 10 14
Node root = new Node(20);
root.left = new Node(8);
root.right = new Node(22);
root.left.left = new Node(4);
root.left.right = new Node(12);
root.left.right.left = new Node(10);
root.left.right.right = new Node(14);
int target = 12;
Node pred = getPred(root, target);
Console.WriteLine(pred != null ? pred.data.ToString() : "null");
}
}
// JavaScript Program to find Inorder Successor in
// Binary Search Tree
class Node {
constructor(x) {
this.data = x;
this.left = null;
this.right = null;
}
}
// Function to find the rightmost (maximum)
// node in the left subtree
function rightmost(node) {
while (node.right !== null) {
node = node.right;
}
return node;
}
function getPred(root, target) {
// No Inorder predecessor
if (root === null) return null;
// Use BST properties to search for the
// target and predecessor
let pred = null;
let curr = root;
while (curr !== null) {
// If the current node's data is less than the target,
// it is a potential predecessor
if (target > curr.data) {
pred = curr;
curr = curr.right;
}
// If greater, move to the left child
else if (target < curr.data) {
curr = curr.left;
}
// If equal
else {
// If the left subtree of target node exists
// then predecessor will be right most node
// of the left subtree.
if (curr.left !== null) {
return rightmost(curr.left);
}
// Otherwise, the predecessor has already
// been stored in the pred variable
break;
}
}
return pred;
}
// Construct a BST
// 20
// / \
// 8 22
// / \
// 4 12
// / \
// 10 14
let root = new Node(20);
root.left = new Node(8);
root.right = new Node(22);
root.left.left = new Node(4);
root.left.right = new Node(12);
root.left.right.left = new Node(10);
root.left.right.right = new Node(14);
let target = 12;
let pred = getPred(root, target);
if (pred !== null)
console.log(pred.data);
else
console.log("null");
Time Complexity: O(h), where h is the height of the tree.
Auxiliary Space: O(1)
Similar Reads
Inorder predecessor in Binary Tree In the Binary Tree, the Inorder predecessor of a node is the previous node in the Inorder traversal of the Binary Tree. The Inorder Predecessor is NULL for the first node in Inorder traversal.Example:In the below diagram, inorder predecessor of node 7 is 3 , node 2 is 7 and node 4 is null. Table of
14 min read
Postorder predecessor of a Node in Binary Search Tree Given a binary tree and a node in the binary tree, find the Postorder predecessor of the given node. Examples: Consider the following binary tree 20 / \ 10 26 / \ / \ 4 18 24 27 / \ 14 19 / \ 13 15 Input : 4 Output : 10 Postorder traversal of given tree is 4, 13, 15, 14, 19, 18, 10, 24, 27, 26, 20.
8 min read
Preorder predecessor of a Node in Binary Tree Given the root of a binary tree and a node of a binary tree, the task is to find the preorder predecessor of the given node. Note: Print -1, if the preorder predecessor of the given node do not exists.Examples: Consider the following binary treeInput: node = 4Output: 10Explanation: Preorder traversa
14 min read
Inorder successor in Binary Tree Given a binary tree and a node, the task is to find the inorder successor of this node. Inorder Successor of a node in the binary tree is the next node in the Inorder traversal of the Binary Tree. Inorder Successor is NULL for the last node in Inorder traversal. In the below diagram, inorder success
15 min read
Level Order Predecessor of a node in Binary Tree Given a binary tree and a node in the binary tree, find Levelorder Predecessor of the given node. That is, the node that appears before the given node in the level order traversal of the tree. Note: The task is not just to print the data of the node, you have to return the complete node from the tre
8 min read
C Program for Binary Search Tree A binary Search Tree is a binary tree where the value of any node is greater than the left subtree and less than the right subtree. In this article, we will discuss Binary Search Trees and various operations on Binary Search trees using C programming language.Properties of Binary Search TreeFollowin
7 min read