# 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[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 ` `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

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