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

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.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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!=B) && (A!=B) )
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 ` `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); ` `    ``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

 ` ``\$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 ` `?> `

Output:

```Yes
```

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.