Get the best out of our app
GFG App
Open App
Browser
Continue

# Check given array of size n can represent BST of n levels or not

Given an array of size n, the task is to find whether array can represent a BST with n levels.
Since levels are n, we construct a tree in the following manner.
Assuming a number X,

• Number higher than X is on the right side
• Number lower than X is on the left side.

Note: during the insertion, we never go beyond a number already visited.

Examples:

```Input : 500, 200, 90, 250, 100
Output : No

Input : 5123, 3300, 783, 1111, 890
Output : Yes```

Explanation :

For the sequence 500, 200, 90, 250, 100 formed tree(in above image) can’t represent BST.

The sequence 5123, 3300, 783, 1111, 890 forms a binary search tree hence its a correct sequence.

Method 1: By constructing BST

We first insert all array values level by level in a Tree. To insert, we check if current value is less than previous value or greater. After constructing the tree, we check if the constructed tree is Binary Search Tree or not.

Implementation:

## C++

 `// C++ program to Check given array` `// can represent BST or not` `#include ` `using` `namespace` `std;`   `// structure for Binary Node` `struct` `Node {` `    ``int` `key;` `    ``struct` `Node *right, *left;` `};`   `Node* newNode(``int` `num)` `{` `    ``Node* temp = ``new` `Node;` `    ``temp->key = num;` `    ``temp->left = NULL;` `    ``temp->right = NULL;` `    ``return` `temp;` `}`   `// To create a Tree with n levels. We always` `// insert new node to left if it is less than` `// previous value.` `Node* createNLevelTree(``int` `arr[], ``int` `n)` `{` `    ``Node* root = newNode(arr[0]);` `    ``Node* temp = root;` `    ``for` `(``int` `i = 1; i < n; i++) {` `        ``if` `(temp->key > arr[i]) {` `            ``temp->left = newNode(arr[i]);` `            ``temp = temp->left;` `        ``}` `        ``else` `{` `            ``temp->right = newNode(arr[i]);` `            ``temp = temp->right;` `        ``}` `    ``}` `    ``return` `root;` `}`   `// Please refer below post for details of this` `// function.` `// https:// www.geeksforgeeks.org/a-program-to-check-if-a-binary-tree-is-bst-or-not/` `bool` `isBST(Node* root, ``int` `min, ``int` `max)` `{` `    ``if` `(root == NULL)` `        ``return` `true``;`   `    ``if` `(root->key < min || root->key > max)` `        ``return` `false``;`   `    ``// Allow only distinct values` `    ``return` `(isBST(root->left, min,` `                  ``(root->key) - 1)` `            ``&& isBST(root->right,` `                     ``(root->key) + 1, max));` `}`   `// Returns tree if given array of size n can` `// represent a BST of n levels.` `bool` `canRepresentNLevelBST(``int` `arr[], ``int` `n)` `{` `    ``Node* root = createNLevelTree(arr, n);` `    ``return` `isBST(root, INT_MIN, INT_MAX);` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 512, 330, 78, 11, 8 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``if` `(canRepresentNLevelBST(arr, n))` `        ``cout << ``"Yes"``;` `    ``else` `        ``cout << ``"No"``;`   `    ``return` `0;` `}`

## Java

 `// Java program to Check given array` `// can represent BST or not` `public` `class` `GFG ` `{`   `    ``// structure for Binary Node` `    ``static` `class` `Node ` `    ``{` `        ``int` `key;` `        ``Node right, left;` `    ``};`   `    ``static` `Node newNode(``int` `num) ` `    ``{` `        ``Node temp = ``new` `Node();` `        ``temp.key = num;` `        ``temp.left = ``null``;` `        ``temp.right = ``null``;` `        ``return` `temp;` `    ``}`   `    ``// To create a Tree with n levels. We always` `    ``// insert new node to left if it is less than` `    ``// previous value.` `    ``static` `Node createNLevelTree(``int` `arr[], ``int` `n) ` `    ``{` `        ``Node root = newNode(arr[``0``]);` `        ``Node temp = root;` `        ``for` `(``int` `i = ``1``; i < n; i++)` `        ``{` `            ``if` `(temp.key > arr[i]) ` `            ``{` `                ``temp.left = newNode(arr[i]);` `                ``temp = temp.left;` `            ``} ` `            ``else` `            ``{` `                ``temp.right = newNode(arr[i]);` `                ``temp = temp.right;` `            ``}` `        ``}` `        ``return` `root;` `    ``}`   `    ``// Please refer below post for details of this` `    ``// function.` `    ``// https:// www.geeksforgeeks.org/a-program-to-check-if-a-binary-tree-is-bst-or-not/` `    ``static` `boolean` `isBST(Node root, ``int` `min, ``int` `max) ` `    ``{` `        ``if` `(root == ``null``) ` `        ``{` `            ``return` `true``;` `        ``}`   `        ``if` `(root.key < min || root.key > max) ` `        ``{` `            ``return` `false``;` `        ``}`   `        ``// Allow only distinct values` `        ``return` `(isBST(root.left, min,` `                ``(root.key) - ``1``)` `                ``&& isBST(root.right,` `                        ``(root.key) + ``1``, max));` `    ``}`   `    ``// Returns tree if given array of size n can` `    ``// represent a BST of n levels.` `    ``static` `boolean` `canRepresentNLevelBST(``int` `arr[], ``int` `n) ` `    ``{` `        ``Node root = createNLevelTree(arr, n);` `        ``return` `isBST(root, Integer.MIN_VALUE, Integer.MAX_VALUE);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``int` `arr[] = {``512``, ``330``, ``78``, ``11``, ``8``};` `        ``int` `n = arr.length;`   `        ``if` `(canRepresentNLevelBST(arr, n)) ` `        ``{` `            ``System.out.println(``"Yes"``);` `        ``} ` `        ``else` `        ``{` `            ``System.out.println(``"No"``);` `        ``}` `    ``}` `}`   `/* This code contributed by PrinciRaj1992 */`

## Python

 `# Python program to Check given array ` `# can represent BST or not `   `# A binary tree node has data, ` `# left child and right child ` `class` `newNode(): `   `    ``def` `__init__(``self``, data): ` `        ``self``.key ``=` `data ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# To create a Tree with n levels. We always ` `# insert new node to left if it is less than ` `# previous value. ` `def` `createNLevelTree(arr, n):` `    ``root ``=` `newNode(arr[``0``]) ` `    ``temp ``=` `root ` `    ``for` `i ``in` `range``(``1``, n):` `        ``if` `(temp.key > arr[i]):` `            ``temp.left ``=` `newNode(arr[i])` `            ``temp ``=` `temp.left ` `        ``else``:` `            ``temp.right ``=` `newNode(arr[i]) ` `            ``temp ``=` `temp.right ` `    `  `    ``return` `root ` `    `  `# Please refer below post for details of this ` `# function. ` `# https:# www.geeksforgeeks.org/a-program-to-check-if-a-binary-tree-is-bst-or-not/ ` `def` `isBST(root, ``min``, ``max``):` `    `  `    ``if` `(root ``=``=` `None``):` `        ``return` `True` `        `  `    ``if` `(root.key < ``min` `or` `root.key > ``max``):` `        ``return` `False` `        `  `    ``# Allow only distinct values ` `    ``return` `(isBST(root.left, ``min``, (root.key) ``-` `1``) ``and` `            ``isBST(root.right,(root.key) ``+` `1``, ``max``))`   `# Returns tree if given array of size n can ` `# represent a BST of n levels. ` `def` `canRepresentNLevelBST(arr, n):` `    `  `    ``root ``=` `createNLevelTree(arr, n) ` `    ``return` `isBST(root, ``0``, ``2``*``*``32``) `   `# Driver code ` `arr ``=` `[``512``, ``330``, ``78``, ``11``, ``8``]` `n ``=` `len``(arr) `   `if` `(canRepresentNLevelBST(arr, n)):` `    ``print``(``"Yes"``)` `else``:` `    ``print``(``"No"``)`   `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// C# program to Check given array` `// can represent BST or not` `using` `System;`   `class` `GFG ` `{`   `    ``// structure for Binary Node` `    ``public` `class` `Node ` `    ``{` `        ``public` `int` `key;` `        ``public` `Node right, left;` `    ``};`   `    ``static` `Node newNode(``int` `num) ` `    ``{` `        ``Node temp = ``new` `Node();` `        ``temp.key = num;` `        ``temp.left = ``null``;` `        ``temp.right = ``null``;` `        ``return` `temp;` `    ``}`   `    ``// To create a Tree with n levels. We always` `    ``// insert new node to left if it is less than` `    ``// previous value.` `    ``static` `Node createNLevelTree(``int` `[]arr, ``int` `n) ` `    ``{` `        ``Node root = newNode(arr[0]);` `        ``Node temp = root;` `        ``for` `(``int` `i = 1; i < n; i++)` `        ``{` `            ``if` `(temp.key > arr[i]) ` `            ``{` `                ``temp.left = newNode(arr[i]);` `                ``temp = temp.left;` `            ``} ` `            ``else` `            ``{` `                ``temp.right = newNode(arr[i]);` `                ``temp = temp.right;` `            ``}` `        ``}` `        ``return` `root;` `    ``}`   `    ``// Please refer below post for details of this` `    ``// function.` `    ``// https:// www.geeksforgeeks.org/a-program-to-check-if-a-binary-tree-is-bst-or-not/` `    ``static` `bool` `isBST(Node root, ``int` `min, ``int` `max) ` `    ``{` `        ``if` `(root == ``null``) ` `        ``{` `            ``return` `true``;` `        ``}`   `        ``if` `(root.key < min || root.key > max) ` `        ``{` `            ``return` `false``;` `        ``}`   `        ``// Allow only distinct values` `        ``return` `(isBST(root.left, min,` `                ``(root.key) - 1) && ` `                ``isBST(root.right,` `                ``(root.key) + 1, max));` `    ``}`   `    ``// Returns tree if given array of size n can` `    ``// represent a BST of n levels.` `    ``static` `bool` `canRepresentNLevelBST(``int` `[]arr, ``int` `n) ` `    ``{` `        ``Node root = createNLevelTree(arr, n);` `        ``return` `isBST(root, ``int``.MinValue, ``int``.MaxValue);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args) ` `    ``{` `        ``int` `[]arr = {512, 330, 78, 11, 8};` `        ``int` `n = arr.Length;`   `        ``if` `(canRepresentNLevelBST(arr, n)) ` `        ``{` `            ``Console.WriteLine(``"Yes"``);` `        ``} ` `        ``else` `        ``{` `            ``Console.WriteLine(``"No"``);` `        ``}` `    ``}` `}`   `// This code contributed by Rajput-Ji`

## Javascript

 ``

Output:

`Yes`

Time Complexity: O(n), we traverse the whole array to create a binary tree, and then traverse it again to check if it is a BST. Thus, the overall time complexity is O(n).
Auxiliary Space: O(n), because we store the complete binary tree in memory.

Method 2 (Array Based):

• Take two variables max = INT_MAX to mark the maximum limit for left subtree and min = INT_MIN to mark the minimum limit for right subtree.
• Loop from arr[1] to arr[n-1]
• for each element check
• If ( arr[i] > arr[i-1] && arr[i] > min && arr[i] < max ), update min = arr[i-1]
• Else if ( arr[i] min && arr[i] < max ), update max = arr[i]
• If none of the above two conditions hold, then element will not be inserted in a new level, so break.

Below is the implementation of the above approach:

## C++

 `// C++ program to Check given array` `// can represent BST or not` `#include ` `using` `namespace` `std;`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 5123, 3300, 783, 1111, 890 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `max = INT_MAX;` `    ``int` `min = INT_MIN;` `    ``bool` `flag = ``true``;`   `    ``for` `(``int` `i = 1; i < n; i++) {`   `        ``// This element can be inserted to the right` `        ``// of the previous element, only if it is greater` `        ``// than the previous element and in the range.` `        ``if` `(arr[i] > arr[i - 1] && arr[i] > min && arr[i] < max) {` `            ``// max remains same, update min` `            ``min = arr[i - 1];` `        ``}` `        ``// This element can be inserted to the left` `        ``// of the previous element, only if it is lesser` `        ``// than the previous element and in the range.` `        ``else` `if` `(arr[i] < arr[i - 1] && arr[i] > min && arr[i] < max) {` `            ``// min remains same, update max` `            ``max = arr[i - 1];` `        ``}` `        ``else` `{` `            ``flag = ``false``;` `            ``break``;` `        ``}` `    ``}`   `    ``if` `(flag) {` `        ``cout << ``"Yes"``;` `    ``}` `    ``else` `{` `        ``// if the loop completed successfully without encountering else condition` `        ``cout << ``"No"``;` `    ``}`   `    ``return` `0;` `}`

## Java

 `// Java program to Check given array ` `// can represent BST or not ` `class` `Solution` `{` `  `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `arr[] = { ``5123``, ``3300``, ``783``, ``1111``, ``890` `}; ` `    ``int` `n = arr.length; ` `    ``int` `max = Integer.MAX_VALUE; ` `    ``int` `min = Integer.MIN_VALUE; ` `    ``boolean` `flag = ``true``; ` `  `  `    ``for` `(``int` `i = ``1``; i < n; i++) { ` `  `  `        ``// This element can be inserted to the right ` `        ``// of the previous element, only if it is greater ` `        ``// than the previous element and in the range. ` `        ``if` `(arr[i] > arr[i - ``1``] && arr[i] > min && arr[i] < max) { ` `            ``// max remains same, update min ` `            ``min = arr[i - ``1``]; ` `        ``} ` `        ``// This element can be inserted to the left ` `        ``// of the previous element, only if it is lesser ` `        ``// than the previous element and in the range. ` `        ``else` `if` `(arr[i] < arr[i - ``1``] && arr[i] > min && arr[i] < max) { ` `            ``// min remains same, update max ` `            ``max = arr[i - ``1``]; ` `        ``} ` `        ``else` `{ ` `            ``flag = ``false``; ` `            ``break``; ` `        ``} ` `    ``} ` `  `  `    ``if` `(flag) { ` `        ``System.out.println(``"Yes"``); ` `    ``} ` `    ``else` `{ ` `        ``// if the loop completed successfully without encountering else condition ` `        ``System.out.println(``"No"``); ` `    ``} ` `  `  `} ` `}` `//contributed by Arnab Kundu`

## Python3

 `# Python3 program to Check given array ` `# can represent BST or not`   `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[``5123``, ``3300``, ``783``, ``1111``, ``890``] ` `    ``n ``=` `len``(arr)` `    ``max` `=` `2147483647` `# INT_MAX ` `    ``min` `=` `-``2147483648` `# INT_MIN ` `    ``flag ``=` `True`   `    ``for` `i ``in` `range``(``1``,n): `   `        ``# This element can be inserted to the ` `        ``# right of the previous element, only ` `        ``# if it is greater than the previous` `        ``# element and in the range. ` `        ``if` `(arr[i] > arr[i ``-` `1``] ``and` `            ``arr[i] > ``min` `and` `arr[i] < ``max``): ` `                `  `            ``# max remains same, update min ` `            ``min` `=` `arr[i ``-` `1``] ` `        `  `        ``# This element can be inserted to the ` `        ``# left of the previous element, only ` `        ``# if it is lesser than the previous ` `        ``# element and in the range. ` `        ``elif` `(arr[i] < arr[i ``-` `1``] ``and` `              ``arr[i] > ``min` `and` `arr[i] < ``max``): ` `                  `  `            ``# min remains same, update max ` `            ``max` `=` `arr[i ``-` `1``] ` `        `  `        ``else` `: ` `            ``flag ``=` `False` `            ``break` `        `  `    ``if` `(flag): ` `        ``print``(``"Yes"``)` `    `  `    ``else``: ` `        `  `        ``# if the loop completed successfully ` `        ``# without encountering else condition ` `        ``print``(``"No"``) ` `    `  `# This code is contributed ` `# by SHUBHAMSINGH10`

## C#

 `using` `System;`   `// C#  program to Check given array  ` `// can represent BST or not  ` `public` `class` `Solution` `{`   `// Driver code  ` `public` `static` `void` `Main(``string``[] args)` `{` `    ``int``[] arr = ``new` `int``[] {5123, 3300, 783, 1111, 890};` `    ``int` `n = arr.Length;` `    ``int` `max = ``int``.MaxValue;` `    ``int` `min = ``int``.MinValue;` `    ``bool` `flag = ``true``;`   `    ``for` `(``int` `i = 1; i < n; i++)` `    ``{`   `        ``// This element can be inserted to the right  ` `        ``// of the previous element, only if it is greater  ` `        ``// than the previous element and in the range.  ` `        ``if` `(arr[i] > arr[i - 1] && arr[i] > min && arr[i] < max)` `        ``{` `            ``// max remains same, update min  ` `            ``min = arr[i - 1];` `        ``}` `        ``// This element can be inserted to the left  ` `        ``// of the previous element, only if it is lesser  ` `        ``// than the previous element and in the range.  ` `        ``else` `if` `(arr[i] < arr[i - 1] && arr[i] > min && arr[i] < max)` `        ``{` `            ``// min remains same, update max  ` `            ``max = arr[i - 1];` `        ``}` `        ``else` `        ``{` `            ``flag = ``false``;` `            ``break``;` `        ``}` `    ``}`   `    ``if` `(flag)` `    ``{` `        ``Console.WriteLine(``"Yes"``);` `    ``}` `    ``else` `    ``{` `        ``// if the loop completed successfully without encountering else condition  ` `        ``Console.WriteLine(``"No"``);` `    ``}`   `}` `}`   ` ``//  This code is contributed by Shrikant13`

## Javascript

 ``

Output:

`Yes`

Time Complexity: O(n)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Similar Reads
Related Tutorials