# Check if a given array can represent Preorder Traversal of Binary Search Tree

• Difficulty Level : Hard
• Last Updated : 21 Sep, 2021

Given an array of numbers, return true if given array can represent preorder traversal of a Binary Search Tree, else return false. Expected time complexity is O(n).

Examples:

Become a success story instead of just reading about them. Prepare for coding interviews at Amazon and other top product-based companies with our Amazon Test Series. Includes topic-wise practice questions on all important DSA topics along with 10 practice contests of 2 hours each. Designed by industry experts that will surely help you practice and sharpen your programming skills. Wait no more, start your preparation today!

```Input:  pre[] = {2, 4, 3}
Output: true
Given array can represent preorder traversal
of below tree
2
\
4
/
3

Input:  pre[] = {2, 4, 1}
Output: false
Given array cannot represent preorder traversal
of a Binary Search Tree.

Input:  pre[] = {40, 30, 35, 80, 100}
Output: true
Given array can represent preorder traversal
of below tree
40
/   \
30    80
\      \
35     100

Input:  pre[] = {40, 30, 35, 20, 80, 100}
Output: false
Given array cannot represent preorder traversal
of a Binary Search Tree.```

A Simple Solution is to do following for every node pre[i] starting from first one.

```1) Find the first greater value on right side of current node.
Let the index of this node be j. Return true if following
conditions hold. Else return false
(i)  All values after the above found greater value are
greater than current node.
(ii) Recursive calls for the subarrays pre[i+1..j-1] and
pre[j+1..n-1] also return true. ```

Time Complexity of the above solution is O(n2)

An Efficient Solution can solve this problem in O(n) time. The idea is to use a stack. This problem is similar to Next (or closest) Greater Element problem. Here we find the next greater element and after finding next greater, if we find a smaller element, then return false.

```1) Create an empty stack.
2) Initialize root as INT_MIN.
3) Do following for every element pre[i]
a) If pre[i] is smaller than current root, return false.
b) Keep removing elements from stack while pre[i] is greater
then stack top. Make the last removed item as new root (to
be compared next).
At this point, pre[i] is greater than the removed root
(That is why if we see a smaller element in step a), we
return false)
c) push pre[i] to stack (All elements in stack are in decreasing
order)  ```

Below is the implementation of above idea.

## C++

 `// C++ program for an efficient solution to check if``// a given array can represent Preorder traversal of``// a Binary Search Tree``#include``using` `namespace` `std;` `bool` `canRepresentBST(``int` `pre[], ``int` `n)``{``    ``// Create an empty stack``    ``stack<``int``> s;` `    ``// Initialize current root as minimum possible``    ``// value``    ``int` `root = INT_MIN;` `    ``// Traverse given array``    ``for` `(``int` `i=0; i

## Java

 `// Java program for an efficient solution to check if``// a given array can represent Preorder traversal of``// a Binary Search Tree``import` `java.util.Stack;``  ` `class` `BinarySearchTree {``  ` `    ``boolean` `canRepresentBST(``int` `pre[], ``int` `n) {``        ``// Create an empty stack``        ``Stack s = ``new` `Stack();``  ` `        ``// Initialize current root as minimum possible``        ``// value``        ``int` `root = Integer.MIN_VALUE;``  ` `        ``// Traverse given array``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``// If we find a node who is on right side``            ``// and smaller than root, return false``            ``if` `(pre[i] < root) {``                ``return` `false``;``            ``}``  ` `            ``// If pre[i] is in right subtree of stack top,``            ``// Keep removing items smaller than pre[i]``            ``// and make the last removed item as new``            ``// root.``            ``while` `(!s.empty() && s.peek() < pre[i]) {``                ``root = s.peek();``                ``s.pop();``            ``}``  ` `            ``// At this point either stack is empty or``            ``// pre[i] is smaller than root, push pre[i]``            ``s.push(pre[i]);``        ``}``        ``return` `true``;``    ``}``  ` `    ``public` `static` `void` `main(String args[]) {``        ``BinarySearchTree bst = ``new` `BinarySearchTree();``        ``int``[] pre1 = ``new` `int``[]{``40``, ``30``, ``35``, ``80``, ``100``};``        ``int` `n = pre1.length;``        ``if` `(bst.canRepresentBST(pre1, n) == ``true``) {``            ``System.out.println(``"true"``);``        ``} ``else` `{``            ``System.out.println(``"false"``);``        ``}``        ``int``[] pre2 = ``new` `int``[]{``40``, ``30``, ``35``, ``20``, ``80``, ``100``};``        ``int` `n1 = pre2.length;``        ``if` `(bst.canRepresentBST(pre2, n) == ``true``) {``            ``System.out.println(``"true"``);``        ``} ``else` `{``            ``System.out.println(``"false"``);``        ``}``    ``}``}``  ` `//This code is contributed by Mayank Jaiswal`

## Python

 `# Python program for an efficient solution to check if``# a given array can represent Preorder traversal of``# a Binary Search Tree` `INT_MIN ``=` `-``2``*``*``32` `def` `canRepresentBST(pre):` `    ``# Create an empty stack``    ``s ``=` `[]` `    ``# Initialize current root as minimum possible value``    ``root ``=` `INT_MIN` `    ``# Traverse given array``    ``for` `value ``in` `pre:``        ``#NOTE:value is equal to pre[i] according to the``        ``#given algo  ``    ` `        ``# If we find a node who is on the right side``        ``# and smaller than root, return False``        ``if` `value < root :``            ``return` `False``    ` `        ``# If value(pre[i]) is in right subtree of stack top,``        ``# Keep removing items smaller than value``        ``# and make the last removed items as new root``        ``while``(``len``(s) > ``0` `and` `s[``-``1``] < value) :``            ``root ``=` `s.pop()``        ` `        ``# At this point either stack is empty or value``        ``# is smaller than root, push value``        ``s.append(value)` `    ``return` `True` `# Driver Program``pre1 ``=` `[``40` `, ``30` `, ``35` `, ``80` `, ``100``]``print` `"true"` `if` `canRepresentBST(pre1) ``=``=` `True` `else` `"false"``pre2 ``=` `[``40` `, ``30` `, ``35` `, ``20` `,  ``80` `, ``100``]``print` `"true"` `if` `canRepresentBST(pre2) ``=``=` `True` `else` `"false"` `# This code is contributed by Nikhil Kumar Singh(nickzuck_007)`

## C#

 `// C# program for an efficient solution``// to check if a given array can represent ``// Preorder traversal of a Binary Search Tree``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `public` `virtual` `bool` `canRepresentBST(``int``[] pre, ``int` `n)``{``    ``// Create an empty stack``    ``Stack<``int``> s = ``new` `Stack<``int``>();` `    ``// Initialize current root as minimum``    ``// possible value``    ``int` `root = ``int``.MinValue;` `    ``// Traverse given array``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``// If we find a node who is on right side``        ``// and smaller than root, return false``        ``if` `(pre[i] < root)``        ``{``            ``return` `false``;``        ``}` `        ``// If pre[i] is in right subtree of stack top,``        ``// Keep removing items smaller than pre[i]``        ``// and make the last removed item as new``        ``// root.``        ``while` `(s.Count > 0 && s.Peek() < pre[i])``        ``{``            ``root = s.Peek();``            ``s.Pop();``        ``}` `        ``// At this point either stack is empty or``        ``// pre[i] is smaller than root, push pre[i]``        ``s.Push(pre[i]);``    ``}``    ``return` `true``;``}` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``GFG bst = ``new` `GFG();``    ``int``[] pre1 = ``new` `int``[]{40, 30, 35, 80, 100};``    ``int` `n = pre1.Length;``    ``if` `(bst.canRepresentBST(pre1, n) == ``true``)``    ``{``        ``Console.WriteLine(``"true"``);``    ``}``    ``else``    ``{``        ``Console.WriteLine(``"false"``);``    ``}``    ``int``[] pre2 = ``new` `int``[]{40, 30, 35, 20, 80, 100};``    ``int` `n1 = pre2.Length;``    ``if` `(bst.canRepresentBST(pre2, n) == ``true``)``    ``{``        ``Console.WriteLine(``"true"``);``    ``}``    ``else``    ``{``        ``Console.WriteLine(``"false"``);``    ``}``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``
Output
```true
false```

Another approach:

We can check if the given preorder traversal is valid or not for a BST without using stack. The idea is to use the similar concept of “Building a BST using narrowing bound algorithm”. We will recursively visit all nodes, but we will not build the nodes. In the end, if the complete array is not traversed, then that means that array can not represent the preorder traversal of any binary tree.

Below is the implementation of the above idea:

## C++

 `// C++ program to illustrate if a given array can represent``// a preorder traversal of a BST or not` `#include ``using` `namespace` `std;` `// We are actually not building the tree``void` `buildBST_helper(``int``& preIndex, ``int` `n, ``int` `pre[],``                     ``int` `min, ``int` `max)``{``    ``if` `(preIndex >= n)``        ``return``;` `    ``if` `(min <= pre[preIndex] && pre[preIndex] <= max) {``        ``// build node``        ``int` `rootData = pre[preIndex];``        ``preIndex++;` `        ``// build left subtree``        ``buildBST_helper(preIndex, n, pre, min, rootData);` `        ``// build right subtree``        ``buildBST_helper(preIndex, n, pre, rootData, max);``    ``}``    ``// else``    ``// return NULL;``}` `bool` `canRepresentBST(``int` `arr[], ``int` `N)``{``    ``// code here``    ``int` `min = INT_MIN, max = INT_MAX;``    ``int` `preIndex = 0;` `    ``buildBST_helper(preIndex, N, arr, min, max);` `    ``return` `preIndex == N;``}` `// Driver Code``int` `main()``{` `    ``int` `preorder1[] = { 2, 4, 3 };``    ``/*``            ``2``            ``\``             ``4``            ``/``           ``3` `*/``    ``int` `n1 = ``sizeof``(preorder1) / ``sizeof``(preorder1);` `    ``if` `(canRepresentBST(preorder1, n1))``        ``cout << ``"\npreorder1 can represent BST"``;``    ``else``        ``cout << ``"\npreorder1 can not represent BST  :("``;` `    ``int` `preorder2[] = { 5, 3, 4, 1, 6, 10 };``    ``int` `n2 = ``sizeof``(preorder2) / ``sizeof``(preorder2);``    ``/*``                    ``5``         ``/     \``       ``3         1``         ``\     /  \``         ``4    6    10` `*/``    ``if` `(canRepresentBST(preorder2, n2))``        ``cout << ``"\npreorder2 can represent BST"``;``    ``else``        ``cout << ``"\npreorder2 can not represent BST  :("``;` `    ``int` `preorder3[] = { 5, 3, 4, 8, 6, 10 };``    ``int` `n3 = ``sizeof``(preorder3) / ``sizeof``(preorder3);``    ``/*``                    ``5``         ``/     \``       ``3         8``         ``\     /  \``         ``4    6    10` `*/``    ``if` `(canRepresentBST(preorder3, n3))``        ``cout << ``"\npreorder3 can represent BST"``;``    ``else``        ``cout << ``"\npreorder3 can not represent BST  :("``;` `    ``return` `0;``}` `// This code is contributed by Sourashis Mondal`

## Java

 `// Java program to illustrate if a given array can represent``// a preorder traversal of a BST or not``public` `class` `Main``{``    ``static` `int` `preIndex = ``0``;``     ` `    ``// We are actually not building the tree``    ``static` `void` `buildBST_helper(``int` `n, ``int``[] pre, ``int` `min, ``int` `max)``    ``{``        ``if` `(preIndex >= n)``            ``return``;``  ` `        ``if` `(min <= pre[preIndex] && pre[preIndex] <= max) {``          ` `            ``// build node``            ``int` `rootData = pre[preIndex];``            ``preIndex++;``  ` `            ``// build left subtree``            ``buildBST_helper(n, pre, min, rootData);``  ` `            ``// build right subtree``            ``buildBST_helper(n, pre, rootData, max);``        ``}``        ``// else``        ``// return NULL;``    ``}``  ` `    ``static` `boolean` `canRepresentBST(``int``[] arr, ``int` `N)``    ``{``        ``// code here``        ``int` `min = Integer.MIN_VALUE, max = Integer.MAX_VALUE;``  ` `        ``buildBST_helper(N, arr, min, max);``  ` `        ``return` `preIndex == N;``    ``}``    ` `    ``public` `static` `void` `main(String[] args) {``        ``int``[] preorder1 = { ``2``, ``4``, ``3` `};``        ``/*``                ``2``                ``\``                 ``4``                ``/``               ``3``        ``*/``        ``int` `n1 = preorder1.length;``        ``System.out.println();``        ``if` `(canRepresentBST(preorder1, n1))``            ``System.out.print(``"preorder1 can represent BST"``);``        ``else``            ``System.out.print(``"preorder1 can not represent BST  :("``);``      ` `        ``int``[] preorder2 = { ``5``, ``3``, ``4``, ``1``, ``6``, ``10` `};``        ``int` `n2 = preorder2.length;``        ``System.out.println();``        ``/*``                        ``5``             ``/     \``           ``3         1``             ``\     /  \``             ``4    6    10``        ``*/``        ``if` `(!canRepresentBST(preorder2, n2))``            ``System.out.print(``"preorder2 can represent BST"``);``        ``else``            ``System.out.print(``"preorder2 can not represent BST  :("``);``      ` `        ``int``[] preorder3 = { ``5``, ``3``, ``4``, ``8``, ``6``, ``10` `};``        ``int` `n3 = preorder3.length;``        ``System.out.println();``        ``/*``                        ``5``             ``/     \``           ``3         8``             ``\     /  \``             ``4    6    10``        ``*/``        ``if` `(canRepresentBST(preorder3, n3))``            ``System.out.print(``"preorder3 can represent BST"``);``        ``else``            ``System.out.print(``"preorder3 can not represent BST  :("``);``    ``}``}` `// This code is contributed by mukesh07.`

## Python3

 `# Python3 program to illustrate if a given array can represent``# a preorder traversal of a BST or not``import` `sys` `preIndex ``=` `0``     ` `# We are actually not building the tree``def` `buildBST_helper(n, pre, ``Min``, ``Max``):``    ``global` `preIndex``    ``if` `(preIndex >``=` `n):``        ``return` `    ``if` `(``Min` `<``=` `pre[preIndex] ``and` `pre[preIndex] <``=` `Max``):``        ``# build node``        ``rootData ``=` `pre[preIndex]``        ``preIndex``+``=``1` `        ``# build left subtree``        ``buildBST_helper(n, pre, ``Min``, rootData)` `        ``# build right subtree``        ``buildBST_helper(n, pre, rootData, ``Max``)``    ``# else``    ``# return NULL` `def` `canRepresentBST(arr, N):``    ``global` `preIndex``    ``# code here``    ``Min``, ``Max` `=` `sys.maxsize, ``-``sys.maxsize` `    ``buildBST_helper(N, arr, ``Min``, ``Max``)``    ` `    ``if` `preIndex ``=``=` `N:``        ``return` `True` `    ``return` `False`` ` `preorder1 ``=` `[ ``2``, ``4``, ``3` `]``"""``        ``2``        ``\``         ``4``        ``/``       ``3` `"""``n1 ``=` `len``(preorder1)` `if` `(``not` `canRepresentBST(preorder1, n1)):``  ``print``(``"preorder1 can represent BST"``);``else``:``  ``print``(``"preorder1 can not represent BST  :("``)` `preorder2 ``=` `[ ``5``, ``3``, ``4``, ``1``, ``6``, ``10` `]``n2 ``=` `len``(preorder2)``"""``                      ``5``           ``/     \``         ``3         1``           ``\     /  \``           ``4    6    10` `"""``if` `(canRepresentBST(preorder2, n2)):``  ``print``(``"preorder2 can represent BST"``)``else``:``  ``print``(``"preorder2 can not represent BST  :("``)` `preorder3 ``=` `[ ``5``, ``3``, ``4``, ``8``, ``6``, ``10` `]``n3 ``=` `len``(preorder3)``"""``                      ``5``           ``/     \``         ``3         8``           ``\     /  \``           ``4    6    10``"""``if` `(``not` `canRepresentBST(preorder3, n3)):``  ``print``(``"preorder3 can represent BST"``)``else``:``  ``print``(``"preorder3 can not represent BST  :("``)`

## C#

 `// C# program to illustrate if a given array can represent``// a preorder traversal of a BST or not``using` `System;``class` `GFG {``    ` `    ``static` `int` `preIndex = 0;``    ` `    ``// We are actually not building the tree``    ``static` `void` `buildBST_helper(``int` `n, ``int``[] pre, ``int` `min, ``int` `max)``    ``{``        ``if` `(preIndex >= n)``            ``return``;`` ` `        ``if` `(min <= pre[preIndex] && pre[preIndex] <= max) {``            ``// build node``            ``int` `rootData = pre[preIndex];``            ``preIndex++;`` ` `            ``// build left subtree``            ``buildBST_helper(n, pre, min, rootData);`` ` `            ``// build right subtree``            ``buildBST_helper(n, pre, rootData, max);``        ``}``        ``// else``        ``// return NULL;``    ``}`` ` `    ``static` `bool` `canRepresentBST(``int``[] arr, ``int` `N)``    ``{``        ``// code here``        ``int` `min = Int32.MinValue, max = Int32.MaxValue;`` ` `        ``buildBST_helper(N, arr, min, max);`` ` `        ``return` `preIndex == N;``    ``}``    ` `  ``static` `void` `Main() {``    ``int``[] preorder1 = { 2, 4, 3 };``    ``/*``            ``2``            ``\``             ``4``            ``/``           ``3``    ``*/``    ``int` `n1 = preorder1.Length;``    ``Console.WriteLine();``    ``if` `(canRepresentBST(preorder1, n1))``        ``Console.Write(``"preorder1 can represent BST"``);``    ``else``        ``Console.Write(``"preorder1 can not represent BST  :("``);`` ` `    ``int``[] preorder2 = { 5, 3, 4, 1, 6, 10 };``    ``int` `n2 = preorder2.Length;``    ``Console.WriteLine();``    ``/*``                    ``5``         ``/     \``       ``3         1``         ``\     /  \``         ``4    6    10``    ``*/``    ``if` `(!canRepresentBST(preorder2, n2))``        ``Console.Write(``"preorder2 can represent BST"``);``    ``else``        ``Console.Write(``"preorder2 can not represent BST  :("``);`` ` `    ``int``[] preorder3 = { 5, 3, 4, 8, 6, 10 };``    ``int` `n3 = preorder3.Length;``    ``Console.WriteLine();``    ``/*``                    ``5``         ``/     \``       ``3         8``         ``\     /  \``         ``4    6    10``    ``*/``    ``if` `(canRepresentBST(preorder3, n3))``        ``Console.Write(``"preorder3 can represent BST"``);``    ``else``        ``Console.Write(``"preorder3 can not represent BST  :("``);``  ``}``}` `// This code is contributed by rameshtravel07.`

## Javascript

 ``
Output
```preorder1 can represent BST
preorder2 can not represent BST  :(
preorder3 can represent BST```

Time complexity: O(N)
Auxiliary Space: O(height of the possible binary tree)