# 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.

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

 ``

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.

My Personal Notes arrow_drop_up