Check if an Array is Sorted (original) (raw)

Last Updated : 13 May, 2025

Try it on GfG Practice

Given an array of size **n, the task is to check if it is **sorted in ascending order or not. Equal values are allowed in an array and two consecutive equal values are considered sorted.

**Examples:

**Input: arr[] = [20, 21, 45, 89, 89, 90]
**Output: Yes

**Input: arr[] = [20, 20, 45, 89, 89, 90]
**Output: Yes

**Input: arr[] = [20, 20, 78, 98, 99, 97]
**Output: No

Table of Content

• Iterative approach - O(n) Time and O(1) Space
• Recursive approach - O(n) Time and O(n) Space

**Iterative approach - O(n) Time and O(1) Space

The idea is simple. We start traversing from the second element. For every element we check if it is smaller than or equal to previous element or not. At any point if we find previous element greater, we return false.

For example [10, 20, 30, 5, 6[

i = 1 : (10 <= 20), continue
i = 2 : (20 <= 30), continue
i = 3 : (30 > 5), return false.

C++ `

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

// Function that returns true if vector is // sorted in non-decreasing order. bool isSorted(const vector& arr) { // For an array to be sorted, every // element must be greater than the // previous element for (int i = 1; i < arr.size(); i++) if (arr[i - 1] > arr[i]) return false;

return true;

}

// Driver code int main() { vector arr = { 20, 23, 23, 45, 78, 88 }; cout << (isSorted(arr) ? "Yes\n" : "No\n"); return 0; }

C

// C program to check if an // Array is sorted or not

#include <stdio.h>

// Function that returns true if array is // sorted in non-decreasing order. int arraySortedOrNot(int arr[], int n) { // Array has one or no element if (n == 0 || n == 1) return 1;

for (int i = 1; i < n; i++) {
    // Unsorted pair found
    if (arr[i - 1] > arr[i])
        return 0;
}

// No unsorted pair found
return 1;

}

// Driver code int main() { int arr[] = { 20, 23, 23, 45, 78, 88 }; int n = sizeof(arr) / sizeof(arr[0]);

if (arraySortedOrNot(arr, n))
    printf("Yes\n");
else
    printf("No\n");

return 0;

}

Java

// Recursive approach to check if an // Array is sorted or not class GFG {

// Function that returns true if array is
// sorted in non-decreasing order.
static boolean arraySortedOrNot(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;
}

// driver code
public static void main(String[] args)
{

    int arr[] = { 20, 23, 23, 45, 78, 88 };
    int n = arr.length;

    if (arraySortedOrNot(arr, n))
        System.out.print("Yes\n");
    else
        System.out.print("No\n");
}

}

// This code is contributed by Anant Agarwal.

Python

Python3 program to check if an

Array is sorted or not

Function that returns true if array is

sorted in non-decreasing order.

def arraySortedOrNot(arr, n):

# 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

Driver code

arr = [20, 23, 23, 45, 78, 88] n = len(arr) if (arraySortedOrNot(arr, n)): print("Yes") else: print("No")

This code is contributed by Anant Agarwal.

C#

// Recursive approach to check if an // Array is sorted or not using System;

class GFG {

// Function that returns true if array is
// sorted in non-decreasing order.
static bool arraySortedOrNot(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;
}

// Driver code
public static void Main(String[] args)
{
    int []arr = { 20, 23, 23, 45, 78, 88 };
    int n = arr.Length;

    if (arraySortedOrNot(arr, n))
        Console.Write("Yes\n");
    else
        Console.Write("No\n");
}

}

// This code is contributed by PrinciRaj1992

JavaScript

// JavaScript program Iterative approach to check if an // Array is sorted or not

// Function that returns true if array is // sorted in non-decreasing order. function arraySortedOrNot(arr, n){

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

}

// Driver Code let arr = [20, 23, 23, 45, 78, 88]; let n = arr.length;

if (arraySortedOrNot(arr, n)) { console.log("Yes"); } else { console.log("No"); }

`

**Recursive approach - O(n) Time and O(n) Space

The basic idea for the recursive approach:

• If size of array is zero or one, return true.
• Check last two elements of array, if they are sorted, perform a recursive call with n-1 else, return false. C++ `

#include #include using namespace std;

// Recursive function that returns true if vector is // sorted in non-decreasing order. bool isSorted(const vector& arr, int n) { // Base case if (n == 1 || n == 0) return true;

// Check if current and previous elements are in order
// and recursively check the rest of the array
return arr[n - 1] >= arr[n - 2] && isSorted(arr, n - 1);

}

// Driver code int main() { vector arr = { 20, 23, 23, 45, 78, 88 }; cout << (isSorted(arr, arr.size()) ? "Yes\n" : "No\n"); return 0; }

C

// C Recursive approach to check if an // Array is sorted or not

#include <stdio.h>

// Function that returns true if array is // sorted in non-decreasing order. int arraySortedOrNot(int a[], int n) { // Base case if (n == 1 || n == 0) { return 1; }

// Check if present index and index
// previous to it are in correct order
// and rest of the array is also sorted
// if true then return true else return
// false
return a[n - 1] >= a[n - 2]
       && arraySortedOrNot(a, n - 1);

}

// Driver code int main() { int arr[] = { 20, 23, 23, 45, 78, 88 }; int n = sizeof(arr) / sizeof(arr[0]);

// Function Call
if (arraySortedOrNot(arr, n)) {
    printf("Yes\n");
}
else {
    printf("No\n");
}

return 0;

}

Java

// Java Recursive approach to check if an // Array is sorted or not class GFG {

// Function that returns true if array is
// sorted in non-decreasing order.
static boolean arraySortedOrNot(int a[], int n)
{
      // base case
    if (n == 1 || n == 0)
        return true;

      // check if present index and index 
    // previous to it are in correct order
    // and rest of the array is also sorted
    // if true then return true else return
    // false
    return a[n - 1] >= a[n - 2]
        && arraySortedOrNot(a, n - 1);
}

// Driver code
public static void main(String[] args)
{

    int arr[] = { 20, 23, 23, 45, 78, 88 };
    int n = arr.length;
    
      // Function Call
    if (arraySortedOrNot(arr, n))
        System.out.print("Yes");
    else
        System.out.print("No");
}

}

// This code is contributed by Durgesh N. Birmiwal.

Python

Python3 recursive program to check

if an Array is sorted or not

Function that returns true if array

is sorted in non-decreasing order.

def arraySortedOrNot(arr, n):

# Base case
if (n == 0 or n == 1):
    return True
    
# Check if present index and index 
# previous to it are in correct order
# and rest of the array is also sorted
# if true then return true else return
# false
return (arr[n - 1] >= arr[n - 2] and
        arraySortedOrNot(arr, n - 1))

Driver code

arr = [ 20, 23, 23, 45, 78, 88 ] n = len(arr)

Function Call

if (arraySortedOrNot(arr, n)): print("Yes") else: print("No")

This code is contributed by Virusbuddah

C#

// C# recursive approach to check if an // Array is sorted or not using System;

class GFG{

// Function that returns true if array is // sorted in non-decreasing order. static bool arraySortedOrNot(int[] a, int n) {

// Base case
if (n == 1 || n == 0)
{
    return true;
}

// Check if present index and index 
// previous to it are in correct order
// and rest of the array is also sorted
// if true then return true else return
// false
return a[n - 1] >= a[n - 2] &&
 arraySortedOrNot(a, n - 1);

}

// Driver code static public void Main() { int[] arr = { 20, 23, 23, 45, 78, 88 }; int n = arr.Length;

// Function Call
if (arraySortedOrNot(arr, n))
{
    Console.WriteLine("Yes");
}
else
{
    Console.WriteLine("No");
}

} }

// This code is contributed by rag2127

JavaScript

// JavaScript Recursive approach to check if an // Array is sorted or not

// Function that returns true if array is // sorted in non-decreasing order. function arraySortedOrNot(a, n) {

// Base case
if (n == 1 || n == 0) {
    return true;
}

// Check if present index and index
// previous to it are in correct order
// and rest of the array is also sorted
// if true then return true else return
// false
return a[n - 1] >= a[n - 2] && arraySortedOrNot(a, n - 1);

}

// Driver code let arr = [20, 23, 23, 45, 78, 88]; let n = arr.length;

// Function Call if (arraySortedOrNot(arr, n)) { console.log("Yes"); } else { console.log("No"); }

`

**Time Complexity: **O(n)
**Auxiliary Space: O(n) for Recursion Call Stack.