Open In App

Postorder predecessor of a Node in Binary Search Tree

Improve
Improve
Like Article
Like
Save
Share
Report

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.

Input :  24
Output : 10

A simple solution is to first store the Postorder traversal of the given tree in an array then linearly search the given node and print the node next to it. 

Complexity Analysis:

  • Time Complexity : O(n) 
  • Auxiliary Space : O(n)

An efficient solution is based on the below observations. 

  1. If the right child of a given node exists, then the right child is the postorder predecessor.
  2. If the right child does not exist and the given node is left child of its parent, then its sibling is its Postorder predecessor.
  3. If none of the above conditions are satisfied (left child does not exist and given node is not the right child of its parent), then we move up using parent pointers until one of the following happens. 
    • We reach the root. In this case, the Postorder predecessor does not exist.
    • The current node (one of the ancestors of the given node) is the right child of its parent, in this case, the postorder predecessor is the sibling of the current node.

Implementation:

C++




// C++ program to find postorder predecessor of
// a node in Binary Tree.
#include <iostream>
using namespace std;
 
struct Node {
    struct Node *left, *right, *parent;
    int key;
};
 
Node* newNode(int key)
{
    Node* temp = new Node;
    temp->left = temp->right = temp->parent = NULL;
    temp->key = key;
    return temp;
}
 
Node* postorderPredecessor(Node* root, Node* n)
{
    // If right child exists, then it is postorder
    // predecessor.
    if (n->right)
        return n->right;
 
    // If right child does not exist, then
    // travel up (using parent pointers)
    // until we reach a node which is right
    // child of its parent.
    Node *curr = n, *parent = curr->parent;
    while (parent != NULL && parent->left == curr) {
        curr = curr->parent;
        parent = parent->parent;
    }
 
    // If we reached root, then the given
    // node has no postorder predecessor
    if (parent == NULL)
        return NULL;
 
    return parent->left;
}
 
int main()
{
    Node* root = newNode(20);
    root->parent = NULL;
    root->left = newNode(10);
    root->left->parent = root;
    root->left->left = newNode(4);
    root->left->left->parent = root->left;
    root->left->right = newNode(18);
    root->left->right->parent = root->left;
    root->right = newNode(26);
    root->right->parent = root;
    root->right->left = newNode(24);
    root->right->left->parent = root->right;
    root->right->right = newNode(27);
    root->right->right->parent = root->right;
    root->left->right->left = newNode(14);
    root->left->right->left->parent = root->left->right;
    root->left->right->left->left = newNode(13);
    root->left->right->left->left->parent = root->left->right->left;
    root->left->right->left->right = newNode(15);
    root->left->right->left->right->parent = root->left->right->left;
    root->left->right->right = newNode(19);
    root->left->right->right->parent = root->left->right;
 
    Node* nodeToCheck = root->left->right;
 
    Node* res = postorderPredecessor(root, nodeToCheck);
 
    if (res) {
        printf("Postorder predecessor of %d is %d\n",
               nodeToCheck->key, res->key);
    }
    else {
        printf("Postorder predecessor of %d is NULL\n",
               nodeToCheck->key);
    }
 
    return 0;
}


Java




// Java program to find postorder predecessor
// of a node in Binary Tree.
import java.util.*;
 
class GFG{
 
static class Node
{
    Node left, right, parent;
    int key;
};
 
static Node newNode(int key)
{
    Node temp = new Node();
    temp.left = temp.right = temp.parent = null;
    temp.key = key;
    return temp;
}
 
static Node postorderPredecessor(Node root, Node n)
{
     
    // If right child exists, then it is
    // postorder predecessor.
    if (n.right != null)
        return n.right;
 
    // If right child does not exist, then
    // travel up (using parent pointers)
    // until we reach a node which is right
    // child of its parent.
    Node curr = n, parent = curr.parent;
    while (parent != null && parent.left == curr)
    {
        curr = curr.parent;
        parent = parent.parent;
    }
 
    // If we reached root, then the given
    // node has no postorder predecessor
    if (parent == null)
        return null;
 
    return parent.left;
}
 
// Driver code
public static void main(String[] args)
{
    Node root = newNode(20);
    root.parent = null;
    root.left = newNode(10);
    root.left.parent = root;
    root.left.left = newNode(4);
    root.left.left.parent = root.left;
    root.left.right = newNode(18);
    root.left.right.parent = root.left;
    root.right = newNode(26);
    root.right.parent = root;
    root.right.left = newNode(24);
    root.right.left.parent = root.right;
    root.right.right = newNode(27);
    root.right.right.parent = root.right;
    root.left.right.left = newNode(14);
    root.left.right.left.parent = root.left.right;
    root.left.right.left.left = newNode(13);
    root.left.right.left.left.parent = root.left.right.left;
    root.left.right.left.right = newNode(15);
    root.left.right.left.right.parent = root.left.right.left;
    root.left.right.right = newNode(19);
    root.left.right.right.parent = root.left.right;
 
    Node nodeToCheck = root.left.right;
 
    Node res = postorderPredecessor(root, nodeToCheck);
 
    if (res != null)
    {
        System.out.printf("Postorder predecessor " +
                          "of %d is %d\n",
                          nodeToCheck.key, res.key);
    }
    else
    {
        System.out.printf("Postorder predecessor " +
                          "of %d is null\n",
                          nodeToCheck.key);
    }
}
}
 
// This code is contributed by Rajput-Ji


Python3




"""Python3 program to find postorder
predecessor of given node."""
 
# A Binary Tree Node
# Utility function to create a
# new tree node
class newNode:
 
    # Constructor to create a newNode
    def __init__(self, data):
        self.key = data
        self.left = None
        self.right = self.parent = None
 
def postorderPredecessor(root, n):
 
    # If right child exists, then it
    # is postorder predecessor.
    if (n.right) :
        return n.right
 
    # If right child does not exist, then
    # travel up (using parent pointers)
    # until we reach a node which is right
    # child of its parent.
    curr = n
    parent = curr.parent
    while (parent != None and
           parent.left == curr):
        curr = curr.parent
        parent = parent.parent
 
    # If we reached root, then the given
    # node has no postorder predecessor
    if (parent == None) :
        return None
 
    return parent.left
 
# Driver Code
if __name__ == '__main__':
 
    root = newNode(20)
    root.parent = None
    root.left = newNode(10)
    root.left.parent = root
    root.left.left = newNode(4)
    root.left.left.parent = root.left
    root.left.right = newNode(18)
    root.left.right.parent = root.left
    root.right = newNode(26)
    root.right.parent = root
    root.right.left = newNode(24)
    root.right.left.parent = root.right
    root.right.right = newNode(27)
    root.right.right.parent = root.right
    root.left.right.left = newNode(14)
    root.left.right.left.parent = root.left.right
    root.left.right.left.left = newNode(13)
    root.left.right.left.left.parent = root.left.right.left
    root.left.right.left.right = newNode(15)
    root.left.right.left.right.parent = root.left.right.left
    root.left.right.right = newNode(19)
    root.left.right.right.parent = root.left.right
 
    nodeToCheck = root.left.right
 
    res = postorderPredecessor(root, nodeToCheck)
 
    if (res) :
        print("Postorder predecessor of",
               nodeToCheck.key, "is", res.key)
     
    else:
        print("Postorder predecessor of",
               nodeToCheck.key, "is None")
 
# This code is contributed
# by SHUBHAMSINGH10


C#




// C# program to find postorder
// predecessor of a node
// in Binary Tree.
using System;
class GFG{
 
class Node
{
  public Node left, right, parent;
  public int key;
};
 
static Node newNode(int key)
{
  Node temp = new Node();
  temp.left = temp.right =
              temp.parent = null;
  temp.key = key;
  return temp;
}
 
static Node postorderPredecessor(Node root,
                                 Node n)
{   
  // If right child exists,
  // then it is postorder
  // predecessor.
  if (n.right != null)
    return n.right;
 
  // If right child does not exist, then
  // travel up (using parent pointers)
  // until we reach a node which is right
  // child of its parent.
  Node curr = n, parent = curr.parent;
  while (parent != null &&
         parent.left == curr)
  {
    curr = curr.parent;
    parent = parent.parent;
  }
 
  // If we reached root, then the given
  // node has no postorder predecessor
  if (parent == null)
    return null;
 
  return parent.left;
}
 
// Driver code
public static void Main(String[] args)
{
  Node root = newNode(20);
  root.parent = null;
  root.left = newNode(10);
  root.left.parent = root;
  root.left.left = newNode(4);
  root.left.left.parent = root.left;
  root.left.right = newNode(18);
  root.left.right.parent = root.left;
  root.right = newNode(26);
  root.right.parent = root;
  root.right.left = newNode(24);
  root.right.left.parent = root.right;
  root.right.right = newNode(27);
  root.right.right.parent = root.right;
  root.left.right.left = newNode(14);
  root.left.right.left.parent = root.left.right;
  root.left.right.left.left = newNode(13);
  root.left.right.left.left.parent = root.left.right.left;
  root.left.right.left.right = newNode(15);
  root.left.right.left.right.parent = root.left.right.left;
  root.left.right.right = newNode(19);
  root.left.right.right.parent = root.left.right;
  Node nodeToCheck = root.left.right;
 
  Node res = postorderPredecessor(root, nodeToCheck);
 
  if (res != null)
  {
    Console.Write("Postorder predecessor " +
                  "of {0} is {1}\n",
                  nodeToCheck.key, res.key);
  }
  else
  {
    Console.Write("Postorder predecessor " +
                  "of {0} is null\n",
                  nodeToCheck.key);
  }
}
}
 
// This code is contributed by shikhasingrajput


Javascript




<script>
 
// Javascript program to find postorder
// predecessor of a node
// in Binary Tree.
 
class Node
{
    constructor()
    {
        this.left = null;
        this.right = null;
        this.parent = null;
        this.key = 0;
    }
};
 
function newNode(key)
{
  var temp = new Node();
  temp.left = temp.right =
              temp.parent = null;
  temp.key = key;
  return temp;
}
 
function postorderPredecessor(root, n)
{   
  // If right child exists,
  // then it is postorder
  // predecessor.
  if (n.right != null)
    return n.right;
 
  // If right child does not exist, then
  // travel up (using parent pointers)
  // until we reach a node which is right
  // child of its parent.
  var curr = n, parent = curr.parent;
  while (parent != null &&
         parent.left == curr)
  {
    curr = curr.parent;
    parent = parent.parent;
  }
 
  // If we reached root, then the given
  // node has no postorder predecessor
  if (parent == null)
    return null;
 
  return parent.left;
}
 
// Driver code
var root = newNode(20);
root.parent = null;
root.left = newNode(10);
root.left.parent = root;
root.left.left = newNode(4);
root.left.left.parent = root.left;
root.left.right = newNode(18);
root.left.right.parent = root.left;
root.right = newNode(26);
root.right.parent = root;
root.right.left = newNode(24);
root.right.left.parent = root.right;
root.right.right = newNode(27);
root.right.right.parent = root.right;
root.left.right.left = newNode(14);
root.left.right.left.parent = root.left.right;
root.left.right.left.left = newNode(13);
root.left.right.left.left.parent = root.left.right.left;
root.left.right.left.right = newNode(15);
root.left.right.left.right.parent = root.left.right.left;
root.left.right.right = newNode(19);
root.left.right.right.parent = root.left.right;
var nodeToCheck = root.left.right;
var res = postorderPredecessor(root, nodeToCheck);
if (res != null)
{
  document.write(`Postorder predecessor ` +
                `of ${nodeToCheck.key} is ${res.key}<br>`);
}
else
{
  document.write(`Postorder predecessor ` +
                `of ${nodeToCheck.key} is null<br>`);
}
 
// This code is contributed by famously.
</script>


Output

Postorder predecessor of 18 is 19

Complexity Analysis:

  • Time Complexity: O(h) where h is the height of given Binary Tree 
  • Auxiliary Space: O(1) 


Last Updated : 18 Aug, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads