Preorder Successor of a Node in Binary Tree

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. 

1. If the left child of a given node exists, then the left child is the preorder successor.
2. If the left child does not exist, however, the right child exists, then the preorder successor is the right child.
3. 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.
4. 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.

C++

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

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

""" Python3 program to find preorder
successor 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 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
    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#

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

Javascript

<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 code
let 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>

Output:

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.