Related Articles

# Check if array can be sorted with one swap

• Difficulty Level : Easy
• Last Updated : 03 Jun, 2021

Given an array containing N elements. Find if it is possible to sort it in non-decreasing order using atmost one swap.
Examples:

Input : arr[] = {1, 2, 3, 4}
Output : YES
Input : arr[] = {3, 2, 1}
Output : YES
Swap 3 and 1 to get [1, 2, 3]
Input : arr[] = {4, 1, 2, 3}
Output :NO

A simple approach is to sort the array and compare the required position of the element and the current position of the element. If there are no mismatches, the array is already sorted. If there are exactly 2 mismatches, we can swap the terms that are not in the position to get the sorted array.

## C++

 `// CPP program to check if an array can be sorted``// with at-most one swap``#include ``using` `namespace` `std;` `bool` `checkSorted(``int` `n, ``int` `arr[])``{``    ``// Create a sorted copy of original array``    ``int` `b[n];``    ``for` `(``int` `i = 0; i < n; i++)``        ``b[i] = arr[i];``    ``sort(b, b + n);` `    ``// Check if 0 or 1 swap required to``    ``// get the sorted array``    ``int` `ct = 0;``    ``for` `(``int` `i = 0; i < n; i++)``        ``if` `(arr[i] != b[i])``            ``ct++;``    ``if` `(ct == 0 || ct == 2)``        ``return` `true``;``    ``else``        ``return` `false``;``}` `// Driver Program to test above function``int` `main()``{``    ``int` `arr[] = {1, 5, 3, 4, 2};``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``if` `(checkSorted(n, arr))``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;``    ``return` `0;``}`

## Java

 `// Java program to check if an array``// can be sorted with at-most one swap``import` `java.util.Arrays;` `class` `GFG``{``static` `boolean` `checkSorted(``int` `n, ``int` `arr[])``{``    ``// Create a sorted copy of original array``    ``int` `[]b = ``new` `int``[n];``    ``for` `(``int` `i = ``0``; i < n; i++)``        ``b[i] = arr[i];``    ``Arrays.sort(b, ``0``, n);` `    ``// Check if 0 or 1 swap required to``    ``// get the sorted array``    ``int` `ct = ``0``;``    ``for` `(``int` `i = ``0``; i < n; i++)``        ``if` `(arr[i] != b[i])``            ``ct++;``    ``if` `(ct == ``0` `|| ct == ``2``)``        ``return` `true``;``    ``else``        ``return` `false``;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = {``1``, ``5``, ``3``, ``4``, ``2``};``    ``int` `n = arr.length;``    ``if` `(checkSorted(n, arr))``        ``System.out.println(``"Yes"``);``    ``else``        ``System.out.println(``"No"``);``}``}` `// This code is contributed by 29AjayKumar`

## Python 3

 `# A linear Python 3 program to check``# if array becomes sorted after one swap` `def` `checkSorted(n, arr):``    ` `    ``# Create a sorted copy of``    ``# original array``    ``b ``=` `[]``    ``for` `i ``in` `range``(n):``        ``b.append(arr[i])``        ` `    ``b.sort()``    ` `    ``# Check if 0 or 1 swap required``    ``# to get the sorted array``    ``ct ``=` `0``    ``for` `i ``in` `range``(n):``        ``if` `arr[i] !``=` `b[i]:``            ``ct ``+``=` `1``            ` `    ``if` `ct ``=``=` `0` `or` `ct ``=``=` `2``:``        ``return` `True``    ``else``:``        ``return` `False` `# Driver Code       ``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[``1``, ``5``, ``3``, ``4``, ``2``]``    ``n ``=` `len``(arr)``    ` `    ``if` `checkSorted(n, arr):``        ``print``(``"Yes"``)``        ` `    ``else``:``        ``print``(``"No"``)` `# This code is contributed``# by Rituraj Jain`

## C#

 `// C# program to check if an array``// can be sorted with at-most one swap``using` `System;` `class` `GFG``{``static` `Boolean checkSorted(``int` `n, ``int` `[]arr)``{``    ``// Create a sorted copy of original array``    ``int` `[]b = ``new` `int``[n];``    ``for` `(``int` `i = 0; i < n; i++)``        ``b[i] = arr[i];``    ``Array.Sort(b, 0, n);` `    ``// Check if 0 or 1 swap required to``    ``// get the sorted array``    ``int` `ct = 0;``    ``for` `(``int` `i = 0; i < n; i++)``        ``if` `(arr[i] != b[i])``            ``ct++;``    ``if` `(ct == 0 || ct == 2)``        ``return` `true``;``    ``else``        ``return` `false``;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = {1, 5, 3, 4, 2};``    ``int` `n = arr.Length;``    ``if` `(checkSorted(n, arr))``        ``Console.WriteLine(``"Yes"``);``    ``else``        ``Console.WriteLine(``"No"``);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``
Output:

`Yes`

Time Complexity: O(n Log n)
An efficient solution is to check in linear time. Let us consider different cases that may appear after one swap.

1. We swap adjacent elements. For example {1, 2, 3, 4, 5} becomes {1, 2, 4, 3, 5}
2. We swap non-adjacent elements. For example {1, 2, 3, 4, 5} becomes {1, 5, 3, 4, 2}

We traverse the given array. For every element, we check if it is smaller than the previous element. We count such occurrences. If the count of such occurrences is more than 2, then we cannot sort the array with one swap. If the count is one, we can find elements to swap (smaller and its previous).
If the count is two, we can find elements to swap (previous of first smaller and second smaller).
After swapping, we again check if array becomes sorted or not. We check this to handle cases like {4, 1, 2, 3}

## C++

 `// A linear CPP program to check if array becomes``// sorted after one swap``#include ``using` `namespace` `std;` `int` `checkSorted(``int` `n, ``int` `arr[])``{``    ``// Find counts and positions of``    ``// elements that are out of order.``    ``int` `first = 0, second = 0;``    ``int` `count = 0;``    ``for` `(``int` `i = 1; i < n; i++) {``        ``if` `(arr[i] < arr[i - 1]) {``            ``count++;``            ``if` `(first == 0)``                ``first = i;``            ``else``                ``second = i;``        ``}``    ``}` `    ``// If there are more than two elements``    ``// are out of order.``    ``if` `(count > 2)``        ``return` `false``;` `    ``// If all elements are sorted already``    ``if` `(count == 0)``        ``return` `true``;` `    ``// Cases like {1, 5, 3, 4, 2}``    ``// We swap 5 and 2.``    ``if` `(count == 2)``        ``swap(arr[first - 1], arr[second]);` `    ``// Cases like {1, 2, 4, 3, 5}``    ``else` `if` `(count == 1)``        ``swap(arr[first - 1], arr[first]);` `    ``// Now check if array becomes sorted``    ``// for cases like {4, 1, 2, 3}``    ``for` `(``int` `i = 1; i < n; i++)``        ``if` `(arr[i] < arr[i - 1])``            ``return` `false``;` `    ``return` `true``;``}` `// Driver Program to test above function``int` `main()``{``    ``int` `arr[] = { 1, 4, 3, 2 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);``    ``if` `(checkSorted(n, arr))``        ``cout << ``"Yes"``;``    ``else``        ``cout << ``"No"``;``    ``return` `0;``}`

## Java

 `// A linear Java program to check if``// array becomes sorted after one swap``class` `GFG``{``static` `boolean` `checkSorted(``int` `n, ``int` `arr[])``{``    ``// Find counts and positions of``    ``// elements that are out of order.``    ``int` `first = ``0``, second = ``0``;``    ``int` `count = ``0``;``    ``for` `(``int` `i = ``1``; i < n; i++)``    ``{``        ``if` `(arr[i] < arr[i - ``1``])``        ``{``            ``count++;``            ``if` `(first == ``0``)``                ``first = i;``            ``else``                ``second = i;``        ``}``    ``}` `    ``// If there are more than two elements``    ``// are out of order.``    ``if` `(count > ``2``)``        ``return` `false``;` `    ``// If all elements are sorted already``    ``if` `(count == ``0``)``        ``return` `true``;` `    ``// Cases like {1, 5, 3, 4, 2}``    ``// We swap 5 and 2.``    ``if` `(count == ``2``)``        ``swap(arr, first - ``1``, second);` `    ``// Cases like {1, 2, 4, 3, 5}``    ``else` `if` `(count == ``1``)``        ``swap(arr, first - ``1``, first);` `    ``// Now check if array becomes sorted``    ``// for cases like {4, 1, 2, 3}``    ``for` `(``int` `i = ``1``; i < n; i++)``        ``if` `(arr[i] < arr[i - ``1``])``            ``return` `false``;` `    ``return` `true``;``}` `static` `int``[] swap(``int` `[]arr, ``int` `i, ``int` `j)``{``    ``int` `temp = arr[i];``    ``arr[i] = arr[j];``    ``arr[j] = temp;``    ``return` `arr;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``1``, ``4``, ``3``, ``2` `};``    ``int` `n = arr.length;``    ``if` `(checkSorted(n, arr))``        ``System.out.println(``"Yes"``);``    ``else``        ``System.out.println(``"No"``);``}``}` `// This code is contributed by Rajput-Ji`

## Python 3

 `# A linear Python 3 program to check``# if array becomes sorted after one swap` `def` `checkSorted(n, arr):``    ` `    ``# Find counts and positions of``    ``# elements that are out of order.``    ``first, second ``=` `0``, ``0``    ``count ``=` `0``    ` `    ``for` `i ``in` `range``(``1``, n):``        ``if` `arr[i] < arr[i ``-` `1``]:``            ``count ``+``=` `1``            ` `            ``if` `first ``=``=` `0``:``                ``first ``=` `i``            ``else``:``                ``second ``=` `i``    ` `    ``# If there are more than two elements``    ``# which are out of order.``    ``if` `count > ``2``:``        ``return` `False` `    ``# If all elements are sorted already``    ``if` `count ``=``=` `0``:``        ``return` `True` `    ``# Cases like {1, 5, 3, 4, 2}``    ``# We swap 5 and 2.``    ``if` `count ``=``=` `2``:``        ``(arr[first ``-` `1``],``         ``arr[second]) ``=` `(arr[second], ``                         ``arr[first ``-` `1``])` `    ``# Cases like {1, 2, 4, 3, 5}``    ``elif` `count ``=``=` `1``:``        ``(arr[first ``-` `1``],``         ``arr[first]) ``=` `(arr[first],``                        ``arr[first ``-` `1``])` `    ``# Now check if array becomes sorted``    ``# for cases like {4, 1, 2, 3}``    ``for` `i ``in` `range``(``1``, n):``        ``if` `arr[i] < arr[i ``-` `1``]:``            ``return` `False` `    ``return` `True` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[``1``, ``4``, ``3``, ``2``]``    ``n ``=` `len``(arr)``    ` `    ``if` `checkSorted(n, arr):``        ``print``(``"Yes"``)``        ` `    ``else``:``        ``print``(``"No"``)` `# This code is contributed``# by Rituraj Jain`

## C#

 `// A linear C# program to check if``// array becomes sorted after one swap``using` `System;` `class` `GFG``{``static` `bool` `checkSorted(``int` `n, ``int` `[]arr)``{``    ``// Find counts and positions of``    ``// elements that are out of order.``    ``int` `first = 0, second = 0;``    ``int` `count = 0;``    ``for` `(``int` `i = 1; i < n; i++)``    ``{``        ``if` `(arr[i] < arr[i - 1])``        ``{``            ``count++;``            ``if` `(first == 0)``                ``first = i;``            ``else``                ``second = i;``        ``}``    ``}` `    ``// If there are more than two elements``    ``// are out of order.``    ``if` `(count > 2)``        ``return` `false``;` `    ``// If all elements are sorted already``    ``if` `(count == 0)``        ``return` `true``;` `    ``// Cases like {1, 5, 3, 4, 2}``    ``// We swap 5 and 2.``    ``if` `(count == 2)``        ``swap(arr, first - 1, second);` `    ``// Cases like {1, 2, 4, 3, 5}``    ``else` `if` `(count == 1)``        ``swap(arr, first - 1, first);` `    ``// Now check if array becomes sorted``    ``// for cases like {4, 1, 2, 3}``    ``for` `(``int` `i = 1; i < n; i++)``        ``if` `(arr[i] < arr[i - 1])``            ``return` `false``;` `    ``return` `true``;``}` `static` `int``[] swap(``int` `[]arr, ``int` `i, ``int` `j)``{``    ``int` `temp = arr[i];``    ``arr[i] = arr[j];``    ``arr[j] = temp;``    ``return` `arr;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 1, 4, 3, 2 };``    ``int` `n = arr.Length;``    ``if` `(checkSorted(n, arr))``        ``Console.WriteLine(``"Yes"``);``    ``else``        ``Console.WriteLine(``"No"``);``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``
Output:
`Yes`

Time Complexity: O(n)
Exercise : How to check if an array can be sorted with two swaps?

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