Given an array of N distinct elements, find the minimum number of swaps required to sort the array.

**Note**: The problem is not asking to sort the array by the minimum number of swaps. The problem is to find the minimum swaps in which the array can be sorted.

**Examples**:

Input: arr[] = {4, 3, 2, 1}Output: 2Explanation: Swap index 0 with 3 and 1 with 2 to get the sorted array {1, 2, 3, 4}.Input: arr[] = { 3, 5, 2, 4, 6, 8}Output: 3Explanation: Swap 4 and 5 so array = 3, 4, 2, 5, 6, 8 Swap 2 and 3 so array = 2, 4, 3, 5, 6, 8 Swap 4 and 3 so array = 2, 3, 4, 5, 6, 8 So the array is sorted.

This problem is already discussed in the previous article using graph. In this article another approach to solve this problem is discussed which is slightly different from the cycle approach.

**Approach:**

The idea is to create a vector of pair in C++ with first element as array values and second element as array indices. The next step is to sort the vector of pair according to the first element of the pair. After that traverse the vector and check if the index mapped with the value is correct or not, if not then keep swapping until the element is placed correctly and keep counting the number of swaps.

**Algorithm:**

- Create a vector of pairs and traverse the array and for every element of the array insert a element-index pair in the vector
- Traverse the vector from start to the end (loop counter is i).
- For every element of the pair where the second element(index) is not equal to i. Swap the ith element of the vector with the second element(index) th element of the vector
- If the second element(index) is equal to i then skip the iteration of the loop.
- if after the swap the second element(index) is not equal to i then decrement i.
- Increment the counter.

**Implementation:**

## CPP

`// CPP program to find the minimum number ` `// of swaps required to sort an array ` `// of distinct element ` ` ` `#include<bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to find minimum swaps to ` `// sort an array ` `int` `findMinSwap(` `int` `arr[] , ` `int` `n) ` `{ ` ` ` `// Declare a vector of pair ` ` ` `vector<pair<` `int` `,` `int` `>> vec(n); ` ` ` ` ` `for` `(` `int` `i=0;i<n;i++) ` ` ` `{ ` ` ` `vec[i].first=arr[i]; ` ` ` `vec[i].second=i; ` ` ` `} ` ` ` ` ` `// Sort the vector w.r.t the first ` ` ` `// element of pair ` ` ` `sort(vec.begin(),vec.end()); ` ` ` ` ` `int` `ans=0,c=0,j; ` ` ` ` ` `for` `(` `int` `i=0;i<n;i++) ` ` ` `{ ` ` ` `// If the element is already placed ` ` ` `// correct, then continue ` ` ` `if` `(vec[i].second==i) ` ` ` `continue` `; ` ` ` `else` ` ` `{ ` ` ` `// swap with its respective index ` ` ` `swap(vec[i].first,vec[vec[i].second].first); ` ` ` `swap(vec[i].second,vec[vec[i].second].second); ` ` ` `} ` ` ` ` ` `// swap until the correct ` ` ` `// index matches ` ` ` `if` `(i!=vec[i].second) ` ` ` `--i; ` ` ` ` ` `// each swap makes one element ` ` ` `// move to its correct index, ` ` ` `// so increment answer ` ` ` `ans++; ` ` ` `} ` ` ` ` ` `return` `ans; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `int` `arr[] = {1, 5, 4, 3, 2}; ` ` ` ` ` `int` `n = ` `sizeof` `(arr)/` `sizeof` `(arr[0]); ` ` ` ` ` `cout<<findMinSwap(arr,n); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to find the minimum number ` `# of swaps required to sort an array ` `# of distinct element ` ` ` `# Function to find minimum swaps to ` `# sort an array ` `def` `findMinSwap(arr, n): ` ` ` ` ` `# Declare a vector of pair ` ` ` `vec ` `=` `[] ` ` ` ` ` `for` `i ` `in` `range` `(n): ` ` ` `vec.append([arr[i], i]) ` ` ` ` ` `# Sort the vector w.r.t the first ` ` ` `# element of pair ` ` ` `vec ` `=` `sorted` `(vec) ` ` ` ` ` `ans, c, j ` `=` `-` `1` `, ` `0` `, ` `0` ` ` ` ` `for` `i ` `in` `range` `(n): ` ` ` ` ` `# If the element is already placed ` ` ` `# correct, then continue ` ` ` `if` `(vec[i][` `1` `] ` `=` `=` `i): ` ` ` `continue` ` ` `else` `: ` ` ` `# swap with its respective index ` ` ` `vec[i][` `0` `], vec[vec[i][` `1` `]][` `1` `] ` `=` `\ ` ` ` `vec[vec[i][` `1` `]][` `1` `], vec[i][` `0` `] ` ` ` `vec[i][` `1` `], vec[vec[i][` `1` `]][` `1` `] ` `=` `\ ` ` ` `vec[vec[i][` `1` `]][` `1` `], vec[i][` `1` `] ` ` ` ` ` `# swap until the correct ` ` ` `# index matches ` ` ` `if` `(i !` `=` `vec[i][` `1` `]): ` ` ` `i ` `-` `=` `1` ` ` ` ` `# each swap makes one element ` ` ` `# move to its correct index, ` ` ` `# so increment answer ` ` ` `ans ` `+` `=` `1` ` ` ` ` `return` `ans ` ` ` `# Driver code ` `arr ` `=` `[` `1` `, ` `5` `, ` `4` `, ` `3` `, ` `2` `] ` `n ` `=` `len` `(arr) ` `print` `(findMinSwap(arr,n)) ` ` ` `# This code is contributed by mohit kumar 29 ` |

*chevron_right*

*filter_none*

**Output:**

2

**Complexity Analysis:**

**Time Complexity:**O(n Log n).

Time required to sort the array is n log n.**Auxiliary Space:**O(n).

An extra array or vector is created. So, the space complexity is O(n log n)

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.

## Recommended Posts:

- Minimum number of swaps required to sort an array of first N number
- Minimum number of swaps required to sort an array
- Minimum adjacent swaps required to Sort Binary array
- Queries to find minimum swaps required to sort given array with updates
- Minimum swaps to reach permuted array with at most 2 positions left swaps allowed
- Minimum number of swaps required for arranging pairs adjacent to each other
- Minimum number of adjacent swaps required to convert a permutation to another permutation by given condition
- Minimum Swaps required to group all 1's together
- Minimum swaps required to bring all elements less than or equal to k together
- Minimum swaps of same indexed elements required to obtain a Majority Element in one of the arrays
- Minimize swaps required to maximize the count of elements replacing a greater element in an Array
- Number of swaps to sort when only adjacent swapping allowed
- Minimum adjacent swaps to move maximum and minimum to corners
- Sort decreasing permutation of N using triple swaps
- Sort permutation of N natural numbers using triple cyclic right swaps
- Minimum increment or decrement required to sort the array | Top-down Approach
- Maximum number formed from array with K number of adjacent swaps allowed
- Minimum number of adjacent swaps for arranging similar elements together
- Minimum number of adjacent swaps to convert a string into its given anagram
- Number of ways in which an item returns back to its initial position in N swaps in array of size K

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.