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 Content

[Naive approach] Using Reverse Inorder - O(n) Time and O(h) Space
[Expected approach] Using Morris Traversal - O(n) Time and O(1) Space

[Naive approach] Using Reverse Inorder - O(n) Time and O(h) Space

To find the inorder predecessor of a target node, we perform a reverse inorder traversal while keeping track of the last visited node. As we traverse, if we locate the target node, we check its left subtree for the predecessor; if found, we return it. If the current root's data matches the target, we return the last visited node from the left subtree as the predecessor. During each step, we update the last visited node and proceed to recursively explore the right subtree, continuing this process until we find the predecessor or complete the traversal.

Below is the implementation of the above approach:

C++

//C++ implemenataton to find Inorder predecessor
//in Binary Serach Tree
#include <bits/stdc++.h>
using namespace std;

class Node {
  
  public:
    int data;
    Node* left;
    Node* right;
  
    Node(int val) {
        data = val;
        left = nullptr;
        right = nullptr;
    }
};

// Function to find the inorder predecessor 
// of a target value.
Node* getPred(Node* root, int target, Node*& last) {
  
    if (!root) return nullptr;

    // Search in the left subtree
    Node* pred = getPred(root->left, target, last);

    // If the predecessor is found in the 
  	// right subtree, return it
    if (pred) return pred;

    // If root's data matches the target, 
  	// return the last visited node
    if (root->data == target)
        return last;

    // Mark the current node as last visited
    last = root;

    // Search in the left subtree
    return getPred(root->right, target, last);
}

int main() {
  
    // Let's construct the binary tree 
    //      1
    //    /    \
    //   2      3
    //  / \    / \
    // 4   5  6   7
    Node* root = new Node(1);
    root->left = new Node(2);
    root->right = new Node(3);
    root->left->left = new Node(4);
    root->left->right = new Node(5);
    root->right->left = new Node(6);
    root->right->right = new Node(7);

    int target = 3;
    Node* last = nullptr;
    Node* pred = getPred(root, target, last);
    
    if (pred)
        cout << pred->data << endl;
    else
        cout << "null" << endl;

    return 0;
}

Java

// Java program to find the inorder predecessor
// of a target value in a binary tree.
class Node {
    int data;
    Node left, right;

    // Constructor to initialize a new Node.
    Node(int val) {
        data = val;
        left = null;
        right = null;
    }
}

class GfG {
    // Function to find the inorder predecessor of a target value.
    static Node getPred(Node root, int target, Node[] last) {
        if (root == null) return null;

        // Search in the right subtree
        Node pred = getPred(root.left, target, last);

        // If the predecessor is found in the right subtree, return it
        if (pred != null) return pred;

        // If root's data matches the target, 
      	// return the last visited node
        if (root.data == target)
            return last[0];

        // Mark the current node as last visited
        last[0] = root;

        // Search in the left subtree
        return getPred(root.right, target, last);
    }

    public static void main(String[] args) {
        // Let's construct the binary tree 
        //      1
        //    /    \
        //   2      3
        //  / \    / \
        // 4   5  6   7
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(6);
        root.right.right = new Node(7);

        // Target node value for which we need to find the predecessor
        int target = 3;
        Node[] last = new Node[1];
        Node pred = getPred(root, target, last);

        if (pred != null)
            System.out.println(pred.data);
        else
            System.out.println("null");
    }
}

Python

# Python program to find the inorder predecessor 
# of a target value in a binary tree.
class Node:
    def __init__(self, val):
        self.data = val
        self.left = None
        self.right = None

def getPred(root, target, last):
    if not root:
        return None

    # Search in the right subtree
    pred = getPred(root.left, target, last)

    # If the predecessor is found in the right subtree, return it
    if pred:
        return pred

    # If root's data matches the target, return the last visited node
    if root.data == target:
        return last[0]

    # Mark the current node as last visited
    last[0] = root

    # Search in the left subtree
    return getPred(root.right, target, last)

if __name__ == "__main__":
    # Let's construct the binary tree 
    #      1
    #    /    \
    #   2      3
    #  / \    / \
    # 4   5  6   7
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.left.right = Node(5)
    root.right.left = Node(6)
    root.right.right = Node(7)

    # Target node value for which we need to find the predecessor
    target = 3
    last = [None]
    pred = getPred(root, target, last)

    if pred:
        print(pred.data)
    else:
        print("null")

// C# program to find the inorder predecessor
// of a target value in a binary tree.

using System;

class Node {
    public int data;
    public Node left, right;

    // Constructor to initialize a new Node.
    public Node(int val) {
        data = val;
        left = null;
        right = null;
    }
}

class GfG {
    // Function to find the inorder predecessor of a target value.
    static Node GetPred(Node root, int target, ref Node last) {
        if (root == null) return null;

        // Search in the right subtree
        Node pred = GetPred(root.left, target, ref last);

        // If the predecessor is found in the right subtree, return it
        if (pred != null) return pred;

        // If root's data matches the target, return the last visited node
        if (root.data == target)
            return last;

        // Mark the current node as last visited
        last = root;

        // Search in the left subtree
        return GetPred(root.right, target, ref last);
    }

    public static void Main() {
        // Let's construct the binary tree 
        //      1
        //    /    \
        //   2      3
        //  / \    / \
        // 4   5  6   7
        Node root = new Node(1);
        root.left = new Node(2);
        root.right = new Node(3);
        root.left.left = new Node(4);
        root.left.right = new Node(5);
        root.right.left = new Node(6);
        root.right.right = new Node(7);

        // Target node value for which we need to find the predecessor
        int target = 3;
        Node last = null;
        Node pred = GetPred(root, target, ref last);

        if (pred != null)
            Console.WriteLine(pred.data);
        else
            Console.WriteLine("null");
    }
}

JavaScript

// JavaScript program to find the inorder predecessor 
// of a target value in a binary tree.
class Node {
    constructor(val) {
        this.data = val;
        this.left = null;
        this.right = null;
    }
}

function getPred(root, target, last) {
    if (!root) return null;

    // Search in the right subtree
    let pred = getPred(root.left, target, last);

    // If the predecessor is found in the right subtree, return it
    if (pred) return pred;

    // If root's data matches the target, return the last visited node
    if (root.data === target)
        return last[0];

    // Mark the current node as last visited
    last[0] = root;

    // Search in the left subtree
    return getPred(root.right, target, last);
}

// Driver Code
const main = () => {
    // Let's construct the binary tree 
    //      1
    //    /    \
    //   2      3
    //  / \    / \
    // 4   5  6   7
    let root = new Node(1);
    root.left = new Node(2);
    root.right = new Node(3);
    root.left.left = new Node(4);
    root.left.right = new Node(5);
    root.right.left = new Node(6);
    root.right.right = new Node(7);

    // Target node value for which we need to find the predecessor
    let target = 3;
    let last = [null];
    let pred = getPred(root, target, last);

    if (pred)
        console.log(pred.data);
    else
        console.log("null");
};

main();

Output

[Expected approach] Using Morris Traversal - O(n) Time and O(1) Space

We can optimize the auxiliary space of above approach used using Morris Traversal (A standard technique to do inorder traversal without stack and recursion).