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.
- If the right child of a given node exists, then the right child is the postorder predecessor.
- If the right child does not exist and the given node is left child of its parent, then its sibling is its Postorder predecessor.
- 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 codepublic 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 = Nonedef 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 Codeif __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 codepublic 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 codevar 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)
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
