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

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

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

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

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

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

Output:

Yes

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