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++ program to Check given array // can represent BST or not #include <bits/stdc++.h> 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 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 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# 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 |
<script> // JavaScript program to Check given array // can represent BST or not // structure for Binary Node class Node { constructor()
{
this .key = 0;
this .left = null ;
this .right = null ;
}
}; function newNode(num)
{ var 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. function createNLevelTree(arr, n)
{ var root = newNode(arr[0]);
var temp = root;
for ( var 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/ */ function isBST(root, min, 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. function canRepresentNLevelBST(arr, n)
{ var root = createNLevelTree(arr, n);
return isBST(root, -1000000000, 1000000000);
} // Driver code var arr = [512, 330, 78, 11, 8];
var n = arr.length;
if (canRepresentNLevelBST(arr, n))
{ document.write( "Yes" );
} else { document.write( "No" );
} </script> |
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++ program to Check given array // can represent BST or not #include <bits/stdc++.h> 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 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 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 |
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
|
<script> // Javascript program to Check given array
// can represent BST or not
let arr = [ 5123, 3300, 783, 1111, 890 ];
let n = arr.length;
let max = Number.MAX_VALUE;
let min = Number.MIN_VALUE;
let flag = true ;
for (let 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)
{
document.write( "Yes" );
}
else
{
// if the loop completed successfully without encountering else condition
document.write( "No" );
}
// This code is contributed by divyesh072019. </script> |
Yes
Time Complexity: O(n)
Auxiliary Space: O(1)