# Sort an almost sorted array where only two elements are swapped

Last Updated : 23 May, 2022

Given an almost sorted array where only two elements are swapped, how to sort the array efficiently?
Examples :

```Input:  arr[] = {10, 20, 60, 40, 50, 30}
// 30 and 60 are swapped
Output: arr[] = {10, 20, 30, 40, 50, 60}

Input:  arr[] = {10, 20, 40, 30, 50, 60}
// 30 and 40 are swapped
Output: arr[] = {10, 20, 30, 40, 50, 60}

Input:   arr[] = {1, 5, 3}
// 3 and 5 are swapped
Output:  arr[] = {1, 3, 5}```

Expected time complexity is O(n) and only one swap operation to fix the array.

The idea is to traverse from rightmost side and find the first out of order element (element which is smaller than previous element). Once first element is found, find the other out of order element by traversing the array toward left side.
Below is implementation of above idea.

## C++

 `// C++ program to sort using one swap` `#include` `#include` `using` `namespace` `std;`   `// This function sorts an array that can be sorted` `// by single swap` `void` `sortByOneSwap(``int` `arr[], ``int` `n)` `{` `    ``// Traverse the given array from rightmost side` `    ``for` `(``int` `i = n-1; i > 0; i--)` `    ``{` `        ``// Check if arr[i] is not in order` `        ``if` `(arr[i] < arr[i-1])` `        ``{` `            ``// Find the other element to be` `            ``// swapped with arr[i]` `            ``int` `j = i-1;` `            ``while` `(j>=0 && arr[i] < arr[j])` `                ``j--;`   `            ``// Swap the pair` `            ``swap(arr[i], arr[j+1]);` `            ``break``;` `        ``}` `    ``}` `}`   `// A utility function to print an array of size n` `void` `printArray(``int` `arr[], ``int` `n)` `{` `    ``int` `i;` `    ``for` `(i=0; i < n; i++)` `        ``cout << arr[i] << ``" "``;` `    ``cout << endl;` `}`   `/* Driver program to test insertion sort */` `int` `main()` `{` `    ``int` `arr[] = {10, 30, 20, 40, 50, 60, 70};` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]);`   `    ``cout << ``"Given array is \n"``;` `    ``printArray(arr, n);`   `    ``sortByOneSwap(arr, n);`   `    ``cout << ``"Sorted array is \n"``;` `    ``printArray(arr, n);`   `    ``return` `0;` `}`

## Java

 `// Java program to ` `// sort using one swap` `import` `java.io.*;`   `class` `GFG ` `{` `// This function sorts an array ` `// that can be sorted by single swap` `static` `void` `sortByOneSwap(``int` `arr[], ` `                          ``int` `n)` `{` `    ``// Traverse the given array` `    ``// from rightmost side` `    ``for` `(``int` `i = n - ``1``; i > ``0``; i--)` `    ``{` `        ``// Check if arr[i] ` `        ``// is not in order` `        ``if` `(arr[i] < arr[i - ``1``])` `        ``{` `            ``// Find the other element ` `            ``// to be swapped with arr[i]` `            ``int` `j = i - ``1``;` `            ``while` `(j >= ``0` `&& arr[i] < arr[j])` `                ``j--;`   `            ``// Swap the pair` `            ``int` `temp = arr[i];` `            ``arr[i] = arr[j + ``1``];` `            ``arr[j + ``1``] = temp;` `    `  `            ``break``;` `        ``}` `    ``}` `}`   `// A utility function to ` `// print an array of size n` `static` `void` `printArray(``int` `arr[], ``int` `n)` `{` `    ``int` `i;` `    ``for` `(i = ``0``; i < n; i++)` `        ``System.out.print(arr[i] + ``" "``);` `    ``System.out.println();` `}`   `// Driver Code` `public` `static` `void` `main(String[] args) ` `{` `int` `arr[] = {``10``, ``30``, ``20``, ` `             ``40``, ``50``, ``60``, ``70``};` `int` `n = arr.length;`   `System.out.println(``"Given array is "``);` `printArray(arr, n);`   `sortByOneSwap(arr, n);`   `System.out.println(``"Sorted array is "``);` `printArray(arr, n);` `}` `}`   `// This code is contributed by anuj_67.`

## Python3

 `# Python program to ` `# sort using one swap`   `# This function sorts an array` `# that can be sorted by single swap` `def` `sortByOneSwap(arr, n):` `  `  `    ``# Traverse the given array` `    ``# from rightmost side` `    ``for` `i ``in` `range``(n ``-` `1``, ``0``, ``-``1``):` `      `  `        ``# Check if arr[i]` `        ``# is not in order` `        ``if` `(arr[i] < arr[i ``-` `1``]):` `          `  `            ``# Find the other element` `            ``# to be swapped with arr[i]` `            ``j ``=` `i ``-` `1``;` `            ``while` `(j >``=` `0` `and` `arr[i] < arr[j]):` `                ``j ``-``=` `1``;`   `            ``# Swap the pair` `            ``temp ``=` `arr[i];` `            ``arr[i] ``=` `arr[j ``+` `1``];` `            ``arr[j ``+` `1``] ``=` `temp;`   `            ``break``;` `        `  `# A utility function to` `# print an array of size n` `def` `printArray(arr, n):` `    ``for` `i ``in` `range``(n):` `        ``print``(arr[i], end ``=` `" "``);` `    ``print``();`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[ ``10``, ``30``, ``20``, ``40``, ``50``, ``60``, ``70` `];` `    ``n ``=` `len``(arr);`   `    ``print``(``"Given array is "``);` `    ``printArray(arr, n);`   `    ``sortByOneSwap(arr, n);`   `    ``print``(``"Sorted array is "``);` `    ``printArray(arr, n);`   `# This code is contributed by gauravrajput1 `

## C#

 `// C# program to sort using one swap ` `using` `System;`   `class` `GFG ` `{ `   `// This function sorts an array ` `// that can be sorted by single swap ` `static` `void` `sortByOneSwap(``int` `[]arr, ` `                          ``int` `n) ` `{ ` `    ``// Traverse the given array ` `    ``// from rightmost side ` `    ``for` `(``int` `i = n - 1; i > 0; i--) ` `    ``{ ` `        ``// Check if arr[i] is not in order ` `        ``if` `(arr[i] < arr[i - 1]) ` `        ``{ ` `            ``// Find the other element to be ` `            ``// swapped with arr[i] ` `            ``int` `j = i - 1; ` `            ``while` `(j >= 0 && arr[i] < arr[j]) ` `                ``j--; `   `            ``// Swap the pair ` `            ``int` `temp = arr[i]; ` `            ``arr[i] = arr[j + 1]; ` `            ``arr[j + 1] = temp; `   `            ``break``; ` `        ``} ` `    ``} ` `} `   `// A utility function to print an ` `// array of size n ` `static` `void` `printArray(``int` `[]arr, ``int` `n) ` `{ ` `    ``int` `i; ` `    ``for` `(i = 0; i < n; i++) ` `        ``Console.Write(arr[i] + ``" "``); ` `    ``Console.WriteLine(); ` `} `   `// Driver Code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `[]arr = {10, 30, 20, ` `                 ``40, 50, 60, 70}; ` `    ``int` `n = arr.Length; `   `    ``Console.WriteLine(``"Given array is "``); ` `    ``printArray(arr, n); `   `    ``sortByOneSwap(arr, n); `   `    ``Console.WriteLine(``"Sorted array is "``); ` `    ``printArray(arr, n); ` `} ` `} `   `// This code is contributed by 29AjayKumar `

## PHP

 ` 0; ``\$i``--)` `    ``{` `        ``// Check if arr[i] ` `        ``// is not in order` `        ``if` `(``\$arr``[``\$i``] < ``\$arr``[``\$i` `- 1])` `        ``{` `            ``// Find the other element ` `            ``// to be swapped with arr[i]` `            ``\$j` `= ``\$i` `- 1;` `            ``while` `(``\$j` `>= 0 && ``\$arr``[``\$i``] < ``\$arr``[``\$j``])` `                ``\$j``--;`   `            ``// Swap the pair` `            ``\$temp` `= ``\$arr``[``\$i``];` `            ``\$arr``[``\$i``] = ``\$arr``[``\$j` `+ 1];` `            ``\$arr``[``\$j` `+ 1] = ``\$temp``;` `    `  `            ``break``;` `        ``}` `    ``}` `}`   `// A utility function to ` `// print an array of size n` `function` `printArray(&``\$arr``, ``\$n``)` `{` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++)` `        ``echo` `\$arr``[``\$i``] . ``" "``;` `    ``echo` `"\n"``;` `}`   `// Driver Code` `\$arr` `= ``array``(10, 30, 20, ` `        ``40, 50, 60, 70);` `\$n` `= sizeof(``\$arr``);`   `echo` `"Given array is "` `. ``"\n"``;` `printArray(``\$arr``, ``\$n``);`   `sortByOneSwap(``\$arr``, ``\$n``);`   `echo` `"Sorted array is "``. ``"\n"``;` `printArray(``\$arr``, ``\$n``);`   `// This code is contributed by Akanksha Rai`

## Javascript

 ``

Output :

```Given array is
10 30 20 40 50 60 70
Sorted array is
10 20 30 40 50 60 70```

Time Complexity: O(N), as we are using a loop to traverse the array.

Auxiliary Space: O(1), as we are not using extra space.
The above program works in O(n) time and swaps only one element.

Previous
Next