Skip to content
Related Articles

Related Articles

Improve Article

Check if given array is almost sorted (elements are at-most one position away)

  • Difficulty Level : Basic
  • Last Updated : 29 Apr, 2021
Geek Week

Given an array with n distinct elements. An array is said to be almost sorted (non-decreasing) if any of its elements can occur at a maximum of 1 distance away from their original places in the sorted array. We need to find whether the given array is almost sorted or not.
Examples: 
 

Input : arr[] = {1, 3, 2, 4}
Output : Yes
Explanation : All elements are either
at original place or at most a unit away. 

Input : arr[] = {1, 4, 2, 3}
Output : No
Explanation : 4 is 2 unit away from
its original place.

 

Sorting Approach : With the help of sorting we can predict whether our given array is almost sorted or not. The idea behind that is first sort the input array say A[]and then if array will be almost sorted then each element Ai of the given array must be equal to any of Bi-1, Bi or Bi+1 of sorted array B[]. 
Time Complexity : O(nlogn) 
 

// suppose B[] is copy of A[]
sort(B, B+n);

// check first element
if ((A[0]!=B[0]) && (A[0]!=B[1]) )
    return 0;
// iterate over array
for(int i=1; i<n-1; i++)
{
    if (A[i]!=B[i-1]) && (A[i]!=B[i]) && (A[i]!=B[i+1]) )
        return false;
}
// check for last element
if ((A[i]!=B[i-1]) && (A[i]!=B[i]) )
    return 0;

// finally return true
return true;

Time complexity: O(n Log n)
Efficient Approach: The idea is based on Bubble Sort. Like Bubble Sort, we compare adjacent elements and swap them if they are not in order. Here after swapping we move the index one position extra so that bubbling is limited to one place. So after one iteration if the resultant array is sorted then we can say that our input array was almost sorted otherwise not almost sorted.
 

// perform bubble sort tech once
for (int i=0; i<n-1; i++)
    if (A[i+1]<A[i])
        swap(A[i], A[i+1]);
        i++;

// check whether resultant is sorted or not
for (int i=0; i<n-1; i++)
    if (A[i+1]<A[i])
        return false;

// If resultant is sorted return true
return true;

 



C++




// CPP program to find whether given array
// almost sorted or not
#include <bits/stdc++.h>
using namespace std;
 
// function for checking almost sort
bool almostSort(int A[], int n)
{
    // One by one compare adjacents.
    for (int i = 0; i < n - 1; i++) {
        if (A[i] > A[i + 1]) {
            swap(A[i], A[i + 1]);
            i++;
        }
    }
 
    // check whether resultant is sorted or not
    for (int i = 0; i < n - 1; i++)
        if (A[i] > A[i + 1])
            return false;
 
    // is resultant is sorted return true
    return true;
}
 
// driver function
int main()
{
    int A[] = { 1, 3, 2, 4, 6, 5 };
    int n = sizeof(A) / sizeof(A[0]);
    if (almostSort(A, n))
        cout << "Yes";
    else
        cout << "No";
    return 0;
}

Java




// JAVA Code to check if given array is almost
// sorted or not
import java.util.*;
 
class GFG {
     
    // function for checking almost sort
    public static boolean almostSort(int A[], int n)
    {
        // One by one compare adjacents.
        for (int i = 0; i < n - 1; i++) {
            if (A[i] > A[i + 1]) {
                int temp = A[i];
                A[i] = A[i+1];
                A[i+1] = temp;
                i++;
            }
        }
      
        // check whether resultant is sorted or not
        for (int i = 0; i < n - 1; i++)
            if (A[i] > A[i + 1])
                return false;
      
        // is resultant is sorted return true
        return true;
    }
     
    /* Driver program to test above function */
    public static void main(String[] args)
    {
        int A[] = { 1, 3, 2, 4, 6, 5 };
        int n = A.length;
        if (almostSort(A, n))
            System.out.print("Yes");
        else
            System.out.print("No");
         
    }
}
   
// This code is contributed by Arnav Kr. Mandal.

Python3




# Python3 program to find whether given
# array almost sorted or not
 
# Function for checking almost sort
def almostSort(A, n):
 
    # One by one compare adjacents.
    i = 0
    while i < n - 1:
        if A[i] > A[i + 1]:
            A[i], A[i + 1] = A[i + 1], A[i]
            i += 1
         
        i += 1
 
    # check whether resultant is sorted or not
    for i in range(0, n - 1):
        if A[i] > A[i + 1]:
            return False
 
    # Is resultant is sorted return true
    return True
 
# Driver Code
if __name__ == "__main__":
 
    A = [1, 3, 2, 4, 6, 5]
    n = len(A)
    if almostSort(A, n):
        print("Yes")
    else:
        print("No")
     
# This code is contributed
# by Rituraj Jain

C#




// C# Code to check if given array
// is almost sorted or not
using System;
 
class GFG {
     
    // function for checking almost sort
    public static bool almostSort(int []A, int n)
    {
         
        // One by one compare adjacents.
        for (int i = 0; i < n - 1; i++)
        {
            if (A[i] > A[i + 1])
            {
                int temp = A[i];
                A[i] = A[i + 1];
                A[i + 1] = temp;
                i++;
            }
        }
     
        // Check whether resultant is
        // sorted or not
        for (int i = 0; i < n - 1; i++)
            if (A[i] > A[i + 1])
                return false;
     
        // is resultant is sorted return true
        return true;
    }
     
    // Driver Code
    public static void Main()
    {
        int []A = {1, 3, 2, 4, 6, 5};
        int n = A.Length;
        if (almostSort(A, n))
            Console.Write("Yes");
        else
            Console.Write("No");
         
    }
}
     
// This code is contributed by Nitin Mittal.

PHP




<?php
// PHP program to find
// whether given array
// almost sorted or not
 
// function for checking
// almost sort
function almostSort($A, $n)
{
    // One by one compare adjacents.
    for ($i = 0; $i < $n - 1; $i++)
    {
        if ($A[$i] > $A[$i + 1])
        {
            list($A[$i],
                 $A[$i + 1]) = array($A[$i + 1],
                                     $A[$i] );
             
            $i++;
        }
    }
 
    // check whether resultant
    // is sorted or not
    for ($i = 0; $i <$n - 1; $i++)
        if ($A[$i] > $A[$i + 1])
            return false;
 
    // is resultant is
    // sorted return true
    return true;
}
 
// Driver Code
$A = array (1, 3, 2,
            4, 6, 5);
$n = sizeof($A) ;
if (almostSort($A, $n))
    echo "Yes", "\n";
else
    echo "Yes", "\n";
     
 
// This code is contributed by ajit
?>

Javascript




<script>
    // Javascript Code to check if given array
    // is almost sorted or not
     
    // function for checking almost sort
    function almostSort(A, n)
    {
           
        // One by one compare adjacents.
        for (let i = 0; i < n - 1; i++)
        {
            if (A[i] > A[i + 1])
            {
                let temp = A[i];
                A[i] = A[i + 1];
                A[i + 1] = temp;
                i++;
            }
        }
       
        // Check whether resultant is
        // sorted or not
        for (let i = 0; i < n - 1; i++)
            if (A[i] > A[i + 1])
                return false;
       
        // is resultant is sorted return true
        return true;
    }
     
    let A = [1, 3, 2, 4, 6, 5];
    let n = A.length;
    if (almostSort(A, n))
      document.write("Yes");
    else
      document.write("No");
     
</script>

Output: 
 

Yes

This article is contributed by Shivam Pradhan (anuj_charm). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up