Preorder Successor of a Node in Binary Tree

Difficulty Level :
Easy
Given a binary tree and a node in the binary tree, find the preorder successor of the given node. It may be assumed that every node has a parent link. Examples:  
Consider the following binary tree
              20            
           /      \         
          10       26       
         /  \     /   \     
       4     18  24    27   
            /  \
           14   19
          /  \
         13  15
Input :  4
Output : 18
Preorder traversal of given tree is 20, 10, 4, 
18, 14, 13, 15, 19, 26, 24, 27.

Input :  19
Output : 26
 
A simple solution is to first store the Preorder traversal of the given tree in an array then linearly search the given node and print the node next to it. Time Complexity: O(n), as we will traverse the tree for searching the node.Auxiliary Space: O(n), as we need extra space for storing the elements of the tree.An efficient solution is based on the below observations. 
If the left child of a given node exists, then the left child is the preorder successor.If the left child does not exist, however, the right child exists, then the preorder successor is the right child.If the left child and the right child does not exist and given node is the left child of its parent, then its sibling is its preorder successor.If none of the above conditions are satisfied (left child does not exist and given node is not left child of its parent), then we move up using parent pointers until one of the following happens. We reach the root. In this case, a preorder successor does not exist.The current node (one of the ancestors of the given node) is the left child of its parent, in this case, the preorder successor is a sibling of the current node.
If the left child of a given node exists, then the left child is the preorder successor.
If the left child does not exist, however, the right child exists, then the preorder successor is the right child.
If the left child and the right child does not exist and given node is the left child of its parent, then its sibling is its preorder successor.
If none of the above conditions are satisfied (left child does not exist and given node is not left child of its parent), then we move up using parent pointers until one of the following happens. We reach the root. In this case, a preorder successor does not exist.The current node (one of the ancestors of the given node) is the left child of its parent, in this case, the preorder successor is a sibling of the current node.
We reach the root. In this case, a preorder successor does not exist.
The current node (one of the ancestors of the given node) is the left child of its parent, in this case, the preorder successor is a sibling of the current node.
 
C++
Java
Python3
C#
Javascript
// CPP program to find preorder successor 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* preorderSuccessor(Node* root, Node* n){    // If left child exists, then it is preorder    // successor.    if (n->left)        return n->left;          // If left child does not exist and right child   // exists, then it is preorder successor.    if (n->right)          return n->right;    // If left child does not exist, then    // travel up (using parent pointers)    // until we reach a node which is left    // child of its parent.    Node *curr = n, *parent = curr->parent;    while (parent != NULL && parent->right == curr) {        curr = curr->parent;        parent = parent->parent;    }     // If we reached root, then the given    // node has no preorder successor    if (parent == NULL)        return NULL;     return parent->right;} 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* res = preorderSuccessor(root, root->left->right->right);     if (res) {        printf("Preorder successor of %d is %d\n",               root->left->right->right->key, res->key);    }    else {        printf("Preorder successor of %d is NULL\n",               root->left->right->right->key);    }     return 0;}
// Java program to find preorder successor of// a node in Binary Tree.class Solution{ 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 preorderSuccessor(Node root, Node n){    // If left child exists, then it is preorder    // successor.    if (n.left != null)        return n.left;        // If left child does not exist and right child    // exists, then it is preorder successor.    if (n.right != null)          return n.right;       // If left child does not exist, then    // travel up (using parent pointers)    // until we reach a node which is left    // child of its parent.    Node curr = n, parent = curr.parent;    while (parent != null && parent.right == curr)    {        curr = curr.parent;        parent = parent.parent;    }     // If we reached root, then the given    // node has no preorder successor    if (parent == null)        return null;     return parent.right;} // 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 res = preorderSuccessor(root, root.left.right.right);     if (res != null)    {        System.out.printf("Preorder successor of %d is %d\n",            root.left.right.right.key, res.key);    }    else    {        System.out.printf("Preorder successor of %d is null\n",            root.left.right.right.key);    }}} // This code is contributed by Arnab Kundu
""" Python3 program to find preordersuccessor of a node in Binary Tree.""" # A Binary Tree Node# Utility function to create a new tree node  class newNode:     # Constructor to create a new node    def __init__(self, data):        self.key = data        self.left = None        self.right = None        self.parent = None  def preorderSuccessor(root, n):     # If left child exists, then it is    # preorder successor.    if (n.left):        return n.left    # If left child does not exist and right child    # exists, then it is preorder successor.    if (n.right):        return n.right    # If left child does not exist, then    # travel up (using parent pointers)    # until we reach a node which is left    # child of its parent.    curr = n    parent = curr.parent    while (parent != None and           parent.right == curr):        curr = curr.parent        parent = parent.parent     # If we reached root, then the given    # node has no preorder successor    if (parent == None):        return None     return parent.right  # 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    res = preorderSuccessor(root, root.left.right.right)     if (res):        print("Preorder successor of",              root.left.right.right.key, "is", res.key)     else:        print("Preorder successor of",              root.left.right.right.key, "is None") # This code is contributed# by SHUBHAMSINGH10
// C# program to find preorder successor of// a node in Binary Tree.using System;     class GFG{ public 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 preorderSuccessor(Node root, Node n){    // If left child exists, then it is preorder    // successor.    if (n.left != null)        return n.left;         // If left child does not exist and right child    // exists, then it is preorder successor.    if (n.right != null)          return n.right;       // If left child does not exist, then    // travel up (using parent pointers)    // until we reach a node which is left    // child of its parent.    Node curr = n, parent = curr.parent;    while (parent != null && parent.right == curr)    {        curr = curr.parent;        parent = parent.parent;    }     // If we reached root, then the given    // node has no preorder successor    if (parent == null)        return null;     return parent.right;} // 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 res = preorderSuccessor(root, root.left.right.right);     if (res != null)    {        Console.Write("Preorder successor of {0} is {1}\n",            root.left.right.right.key, res.key);    }    else    {        Console.Write("Preorder successor of {0} is null\n",            root.left.right.right.key);    }}} // This code is contributed by 29AjayKumar
<script> // JavaScript program to find preorder successor of// a node in Binary Tree. class Node{    constructor(key)    {        this.key=key;        this.left=this.right=this.parent=null;    }} function preorderSuccessor(root,n){    // If left child exists, then it is preorder    // successor.    if (n.left != null)        return n.left;       // If left child does not exist and right child    // exists, then it is preorder successor.    if (n.right != null)          return n.right;       // If left child does not exist, then    // travel up (using parent pointers)    // until we reach a node which is left    // child of its parent.    let curr = n, parent = curr.parent;    while (parent != null && parent.right == curr)    {        curr = curr.parent;        parent = parent.parent;    }       // If we reached root, then the given    // node has no preorder successor    if (parent == null)        return null;       return parent.right;} // Driver codelet root = new Node(20);    root.parent = null;    root.left = new Node(10);    root.left.parent = root;    root.left.left = new Node(4);    root.left.left.parent = root.left;    root.left.right = new Node(18);    root.left.right.parent = root.left;    root.right = new Node(26);    root.right.parent = root;    root.right.left = new Node(24);    root.right.left.parent = root.right;    root.right.right = new Node(27);    root.right.right.parent = root.right;    root.left.right.left = new Node(14);    root.left.right.left.parent = root.left.right;    root.left.right.left.left = new Node(13);    root.left.right.left.left.parent = root.left.right.left;    root.left.right.left.right = new Node(15);    root.left.right.left.right.parent = root.left.right.left;    root.left.right.right = new Node(19);    root.left.right.right.parent = root.left.right;       let res = preorderSuccessor(root, root.left.right.right);       if (res != null)    {        document.write("Preorder successor of "+        root.left.right.right.key+" is "+res.key+"<br>");    }    else    {        System.out.printf("Preorder successor of "+        root.left.right.right.key+" is null<br>");                 }  // This code is contributed by avanitrachhadiya2155 </script>
Preorder successor of 19 is 26
 
Time Complexity: O(h) where h is the height of the given Binary Tree, as we are not traversing all nodes. We have checked the child of each node that is equivalent to traversing the height of the tree.Auxiliary Space: O(1), as we are not using any extra space. 
AnkurSachdeva1
SHUBHAMSINGH10
andrew1234
29AjayKumar
avanitrachhadiya2155
dhruvshah2597
rohitsingh07052
Binary Tree
Preorder Traversal
Tree
Tree
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
Introduction to Tree Data Structure
What is Data Structure: Types, Classifications and Applications
Binary Tree | Set 2 (Properties)
Diameter of a Binary Tree
Lowest Common Ancestor in a Binary Tree | Set 1
Decision Tree
Diagonal Traversal of Binary Tree
Construct Tree from given Inorder and Preorder traversals
Insertion in a Binary Tree in level order