Open In App

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

Improve
Improve
Like Article
Like
Save
Share
Report

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;

Algorithm:

  1.    Sort the copy of input array A to get the sorted array B.
  2.    Check if the first element of A is either the first or second element of B. If not, return false
  3.    Iterate through the array A from the second element to the second-to-last element
  4.    For each element A[i] of A, check if it is equal to A[i-1], A[i], or A[i+1] in B. If not, return false
  5.    Check if the last element of A is either the second-to-last or last element of B. If not, return false
  6.    If all checks pass, return true.

Below is the implementation of the approach:

C++





Java





Python3





C#





Javascript





Output

Yes



Time complexity: O(n Log n)

Auxiliary Space: O(n) as an array B has been created to store copy of input array A. Here, n is size of the input array.

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++





Java





Python3





C#





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>


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
?>


Output: 
 

Yes

Time Complexity: O(N), as we are using any loops for traversing.

Auxiliary Space: O(1), as we are not using any extra space.


 



Last Updated : 29 Nov, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads