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

Problem Statement:

You're given an array of size n and you need to determine if the elements in the array can be used to construct a Binary Search Tree (BST) with exactly n levels. The construction follows a specific rule for arranging elements in a tree. Let's consider a number X;

Number greater than X is on the right side
Number smaller than X is on the left side.

Note: Before insertion of number, we never go beyond a number already visited.

Example 1:

Input: 500, 200, 90, 250, 100

The given array represents the following elements in a BST (assuming that the left child is less than the parent, and the right child is greater than the parent):

In this case, the BST has 4 levels, not 5 as indicated by the number of elements in the array. Therefore, the output is "No".

Input: 5123, 3300, 783, 1111, 890

The given array represents the following elements in a BST:

In this case, the BST has 4 levels, matching the number of elements in the array. Therefore, the output is "Yes".

Approach 1: Building a BST Representation

The method involves populating a tree structure by inserting the elements from the given array in a specific order that mimics a binary search tree (BST). Each element is placed according to whether it is less or greater than the preceding element. Once the tree is constructed, a check is performed to determine if the resulting structure is a valid binary search tree or not.

Algorithm:

Algorithm ConstructBSTandCheckValidity(arr):
  Define a root node as null

  1. For each element in the array arr:
     a. Create a new node with the element as data.
     b. Insert the node into the BST based on its value.

  2. Set prevNode as null
  3. Perform inorder traversal of the BST:
     a. If the current node's value is less than or equal to prevNode's value, return false.
     b. Update prevNode to the current node.
  4. If traversal completes without violating BST property, return true (valid BST).

Java Implementation of the above approach

class TreeNode {
    int key;
    TreeNode left, right;

    TreeNode(int item) {
        // Constructor to create a new node with a given key
        key = item;
        left = right = null;
    }
}

public class ArrayToBST {

    private static TreeNode createNode(int value) {
        // Create a new TreeNode with the given value
        return new TreeNode(value);
    }

    private static TreeNode buildNLevelTree(int[] arr, int n) {
        // Build a binary tree based on the given array

        // Start by creating the root node with the first element of the array
        TreeNode root = createNode(arr[0]);
        TreeNode currentNode = root;

        // Iterate through the array and construct the tree
        for (int i = 1; i < n; i++) {
            if (currentNode.key > arr[i]) {
                // If the current element is less than the current node's key, insert to the left
                currentNode.left = createNode(arr[i]);
                currentNode = currentNode.left;
            } else {
                // If the current element is greater or equal, insert to the right
                currentNode.right = createNode(arr[i]);
                currentNode = currentNode.right;
            }
        }

        return root;
    }

    private static boolean isBST(TreeNode root, int min, int max) {
        // Check if the given binary tree is a valid Binary Search Tree (BST)

        // Base case: an empty tree is a valid BST
        if (root == null)
            return true;

        // Check if the current node's key is within the valid range
        if (root.key < min || root.key > max)
            return false;

        // Recur for the left and right subtrees with updated min and max values
        return isBST(root.left, min, (root.key) - 1) && isBST(root.right, (root.key) + 1, max);
    }

    private static boolean canRepresentNLevelBST(int[] arr, int n) {
        // Check if the given array can represent a Binary Search Tree (BST) with n levels

        // Build a binary tree from the given array
        TreeNode root = buildNLevelTree(arr, n);

        // Check if the constructed tree is a valid BST
        return isBST(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
    }

    public static void main(String[] args) {
        // Sample input array
        int[] arr = {512, 330, 78, 11, 8};
        int n = arr.length;

        // Check if the array can represent an n-level BST
        if (canRepresentNLevelBST(arr, n))
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}

Time Complexity:

The time complexity of constructing the binary tree is O(n), where n is the number of elements in the array. This is because we traverse each element in the array once to build the tree.

The time complexity of checking if the constructed tree is a valid BST (using inorder traversal) is also O(n), as we visit each node once.

Overall, the time complexity is O(n) due to the dominant factor being the tree construction and validation.

Space Complexity:

The space complexity for creating the tree is O(n) in the worst case. This is because we need to store all n elements in the array in the tree.

The space complexity for the recursive stack during BST validation is O(h), where h is the height of the tree. In a balanced BST, the height h is O(log n), but in the worst case (skewed tree), it can be O(n).

Therefore, the overall space complexity is O(max(n, h)). In the worst case, it can be O(n) for a skewed tree.

Approach 2: Using Array

Utilize two variables, 'max' initialized to INT_MAX to denote the upper limit for the left subtree, and 'min' initialized to INT_MIN to denote the lower limit for the right subtree. Iterate through the array from arr[1] to arr[n-1].
For each element in the array, perform the following checks:
If the current element (arr[i]) is greater than the previous element (arr[i-1]) and falls within the range between 'min' and 'max', update 'min' with the value of arr[i-1].
If the current element is not greater than the previous element but still falls within the range between 'min' and 'max', update 'max' with the value of the current element.
If neither of the above two conditions holds true, it implies that the current element cannot be inserted into a new level, and therefore, break out of the loop.

By applying these conditions, you can effectively determine the boundaries for left and right subtrees while traversing the array

Java Implementation of the above approach

import java.util.Arrays;

public class CheckBSTRepresentation {

    public static void main(String[] args) {
        int[] values = { 5123, 3300, 783, 1111, 890 };
        int n = values.length;
        int max = Integer.MAX_VALUE; // Initialize the 'max' variable with the maximum possible value.
        int min = Integer.MIN_VALUE; // Initialize the 'min' variable with the minimum possible value.
        boolean isBST = true; // A flag to track whether the array represents a Binary Search Tree (BST).

        // Iterate through the 'values' array starting from the second element (index 1).
        for (int i = 1; i < n; i++) {
            if (values[i] > values[i - 1] && values[i] > min && values[i] < max) {
                // Condition 1: The current element can be inserted to the right of the previous element
                // if it is greater than the previous element and falls within the range specified by 'min' and 'max'.

                // In this case, update 'min' to be the previous element, as it becomes the new lower bound.
                min = values[i - 1];
            } else if (values[i] < values[i - 1] && values[i] > min && values[i] < max) {
                // Condition 2: The current element can be inserted to the left of the previous element
                // if it is lesser than the previous element and falls within the range specified by 'min' and 'max'.

                // In this case, update 'max' to be the previous element, as it becomes the new upper bound.
                max = values[i - 1];
            } else {
                // If neither Condition 1 nor Condition 2 is met, it indicates that the array does not represent a BST.
                isBST = false;
                break; // Exit the loop since further comparisons are unnecessary.
            }
        }

        // After the loop, check the 'isBST' flag to determine if the array represents a BST.
        if (isBST) {
            System.out.println("Yes"); // Output "Yes" if it's a BST.
        } else {
            System.out.println("No"); // Output "No" if it's not a BST.
        }
    }
}

Time Complexity: The time complexity of this code is O(n) in the worst case, where 'n' is the number of elements in the 'values' array. This is because it iterates through the entire array once, performing constant-time operations for each element.

Space Complexity: The space complexity of this code is O(1), which means it uses a constant amount of memory regardless of the input size. It only uses a few integer variables ('max', 'min', 'n', 'i', 'isBST') and does not require additional memory that scales with the input size.

Next TopicConstruct a linked list from 2D matrix

← prev next →