Check if an array can be Preorder of a BST

// Java program to check if given array can represent Preorder
// traversal of a Binary Search Tree

import java.util.*;

class GfG {
    
    static boolean canRepresentBST(List<Integer> pre) {

        Stack<Integer> s = new Stack<>();

        // Initialize current root as minimum possible
        // value
        int root = Integer.MIN_VALUE;

        for (int i = 0; i < pre.size(); i++) {
          
            // If we find a node who is on right side
            // and smaller than root, return false
            if (pre.get(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.isEmpty() && s.peek() < pre.get(i)) {
                root = s.pop();
            }

            // At this point either stack is empty or
            // pre[i] is smaller than root, push pre[i]
            s.push(pre.get(i));
        }
        return true;
    }

    public static void main(String[] args) {
        List<Integer> pre = Arrays.asList(40, 30, 35, 80, 100);

        if (canRepresentBST(pre))
            System.out.println("true");
        else
            System.out.println("false");
    }
}

// Java program to check if a given array can represent
// a preorder traversal of a BST or not

import java.util.*;

class GfG {

    static void buildBSThelper(int[] preIndex, int n, List<Integer> pre,
                                       int min, int max) {

        // If we have processed all elements, return
        if (preIndex[0] >= n)
            return;

        // If the current element lies between min and max, 
        // it can be part of the BST
        if (min <= pre.get(preIndex[0]) && pre.get(preIndex[0]) <= max) {
          
            // Treat the current element as the root of this subtree
            int rootData = pre.get(preIndex[0]);
            preIndex[0]++;


            buildBSThelper(preIndex, n, pre, min, rootData);
            buildBSThelper(preIndex, n, pre, rootData, max);
        }
    }

    // Function to check if the array can represent a 
  	// valid BST
    static boolean canRepresentBST(List<Integer> arr) {

        // Set the initial min and max values
        int min = Integer.MIN_VALUE, max = Integer.MAX_VALUE;

        // Start from the first element in the array
        int[] preIndex = {0};
        int n = arr.size();

        buildBSThelper(preIndex, n, arr, min, max);

        // If all elements are processed, it means the 
        // array represents a valid BST
        return preIndex[0] == n;
    }

    public static void main(String[] args) {
      
        List<Integer> pre = Arrays.asList(40, 30, 35, 80, 100);
        if (canRepresentBST(pre))
            System.out.println("true");
        else
            System.out.println("false");
    }
}