Inorder predecessor in Binary Search Tree

Last Updated : 14 Feb, 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

// 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

# 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

// 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");

Output

Time Complexity: O(h), where h is the height of the tree.
Auxiliary Space: O(1)

Preorder predecessor of a Node in Binary Tree

vaibhavvah36o

Improve

Article Tags :

Practice Tags :

Binary Search Tree

Inorder predecessor in Binary Search Tree

Similar Reads

Thank You!

What kind of Experience do you want to share?