Name: Inorder Traversal and BST DSA Problem
Uploaded: 2024-05-02T16:03:11Z
Duration: 6 min 14 s

Given an array arr[] of size n containing unique elements, check whether it represents the inorder traversal of a Binary Search Tree (BST) or not.

Examples:

Input: arr[] = { 19, 23, 25, 30, 45 }
Output: true
Explaination: Given array is inorder traversal for the following tree:

Input : arr[] = { 19, 23, 30, 25, 45 }
Output : false
Explanation: The array is not in increasing order (since 30 > 25), so it cannot represent the inorder traversal of a Binary Search Tree (BST).

Try It Yourself

The idea is to use the fundamental property of BST: Inorder traversal of a Binary Search Tree always gives a sorted sequence. So, simply check whether the given array is sorted in increasing order or not.

C++

#include<bits/stdc++.h>
using namespace std;

// Function that returns true if array is Inorder
// traversal of any Binary Search Tree or not.
bool doesRepresentBST(vector<int> &arr) {
    int n = arr.size();
  
    // Array has one or no element
    if (n == 0 || n == 1)
        return true;

    for (int i = 1; i < n; i++)

        // Unsorted pair found
        if (arr[i-1] > arr[i])
            return false;

    // No unsorted pair found
    return true;
}

int main() {
    vector<int> arr = { 19, 23, 25, 30, 45 };
    
    if (doesRepresentBST(arr))
        cout << "true";
    else
        cout << "false";
        
  return 0;
}

#include <stdio.h>
#include <stdbool.h>

// Function that returns true if array is Inorder
// traversal of any Binary Search Tree or not.
bool doesRepresentBST(int arr[], int n) {

    // Array has one or no element
    if (n == 0 || n == 1)
        return true;

    for (int i = 1; i < n; i++) {

        // Unsorted pair found
        if (arr[i-1] > arr[i])
            return false;
    }

    // No unsorted pair found
    return true;
}

int main() {
    int arr[] = { 19, 23, 25, 30, 45 };
    int n = sizeof(arr) / sizeof(arr[0]);

    if (doesRepresentBST(arr, n))
        printf("true");
    else
        printf("false");

    return 0;
}

Java

import java.util.ArrayList;

class GfG {

    // Function that returns true if array is Inorder
    // traversal of any Binary Search Tree or not.
    static boolean doesRepresentBST(ArrayList<Integer> arr) {
        int n = arr.size();

        // Array has one or no element
        if (n == 0 || n == 1)
            return true;

        for (int i = 1; i < n; i++) {

            // Unsorted pair found
            if (arr.get(i - 1) > arr.get(i))
                return false;
        }

        // No unsorted pair found
        return true;
    }

    public static void main(String[] args) {
        ArrayList<Integer> arr = new ArrayList<>();
        arr.add(19);
        arr.add(23);
        arr.add(25);
        arr.add(30);
        arr.add(45);

        if (doesRepresentBST(arr))
            System.out.println("true");
        else
            System.out.println("false");
    }
}

Python

# Function that returns true if array is Inorder
# traversal of any Binary Search Tree or not.
def doesRepresentBST(arr):
    n = len(arr)

    # Array has one or no element
    if n == 0 or n == 1:
        return True

    for i in range(1, n):

        # Unsorted pair found
        if arr[i-1] > arr[i]:
            return False

    # No unsorted pair found
    return True

if __name__ == "__main__":
    arr = [19, 23, 25, 30, 45]

    if doesRepresentBST(arr):
        print("true")
    else:
        print("false")

using System;
using System.Collections.Generic;

class GfG {

    // Function that returns true if array is Inorder
    // traversal of any Binary Search Tree or not.
    static bool doesRepresentBST(List<int> arr) {
        int n = arr.Count;

        // Array has one or no element
        if (n == 0 || n == 1)
            return true;

        for (int i = 1; i < n; i++) {

            // Unsorted pair found
            if (arr[i-1] > arr[i])
                return false;
        }

        // No unsorted pair found
        return true;
    }

    static void Main() {
        List<int> arr = new List<int> { 19, 23, 25, 30, 45 };

        if (doesRepresentBST(arr))
            Console.WriteLine("true");
        else
            Console.WriteLine("false");
    }
}

JavaScript

// Function that returns true if array is Inorder
// traversal of any Binary Search Tree or not.
function doesRepresentBST(arr) {
    let n = arr.length;

    // Array has one or no element
    if (n === 0 || n === 1)
        return true;

    for (let i = 1; i < n; i++) {

        // Unsorted pair found
        if (arr[i-1] > arr[i])
            return false;
    }

    // No unsorted pair found
    return true;
}

const arr = [19, 23, 25, 30, 45];

if (doesRepresentBST(arr))
    console.log("true");
else
    console.log("false");

Output

true

Check if an array represents Inorder of Binary Search tree or not

Explore