Minimum number of swaps required to sort an array | Set 2 (original) (raw)

Last Updated : 28 Dec, 2022

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: 2 Explanation: 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: 3 Explanation: 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:

  1. Create a vector of pairs and traverse the array and for every element of the array insert a element-index pair in the vector
  2. Traverse the vector from start to the end (loop counter is i).
  3. 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
  4. If the second element(index) is equal to i then skip the iteration of the loop.
  5. if after the swap the second element(index) is not equal to i then decrement i.
  6. Increment the counter.

Implementation:

C++ `

// C++ 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;

}

Java

// Java program to find the minimum number
// of swaps required to sort an array // of distinct element import java.util.*; class GFG {

static class Point implements Comparable {

public int x, y;    
public Point(int x, int y)
{
    this.x = x;
    this.y = y;
}

public int compareTo(Point other)
{ 
    return this.x - other.x;
}

}

// Function to find minimum swaps to
// sort an array static int findMinSwap(int[] arr, int n) {

// Declare a vector of pair   
List<Point> vec = new ArrayList<Point>(); 
                                       
for(int i = 0; i < n; i++) 
{ 
    vec.add(new Point(arr[i], i));
} 

// Sort the vector w.r.t the first 
// element of pair 
Collections.sort(vec);   
int ans = 0; 
for(int i = 0; i < n; i++) 
{  
     
    // If the element is already placed 
    // correct, then continue 
    if (vec.get(i).y == i)  
        continue; 
    else
    { 
         
        // Swap with its respective index  
        Point temp = vec.get(vec.get(i).y);
        vec.set(vec.get(i).y,vec.get(i));
        vec.set(i, temp);
    }  
     
    // Swap until the correct  
    // index matches 
    if (i != vec.get(i).y) 
        --i; 
       
    // Each swap makes one element 
    // move to its correct index,  
    // so increment answer 
    ans++; 
} 
return ans;

}

// Driver Code public static void main(String []args) { int[] arr = { 1, 5, 4, 3, 2 }; int n = arr.length;
System.out.println(findMinSwap(arr,n)); } }

// This code is contributed by Pratham76

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

C#

// C# program to find the minimum number
// of swaps required to sort an array // of distinct element using System; using System.Collections.Generic;

class GFG{

// Function to find minimum swaps to
// sort an array static int findMinSwap(int[] arr, int n) {

// Declare a vector of pair   
List<Tuple<int,
           int>> vec = new List<Tuple<int,
                                      int>>(); 
                                      
for(int i = 0; i < n; i++) 
{ 
    vec.Add(new Tuple<int, int>(arr[i], i));
} 

// Sort the vector w.r.t the first 
// element of pair 
vec.Sort(); 

int ans = 0; 

for(int i = 0; i < n; i++) 
{  
    
    // If the element is already placed 
    // correct, then continue 
    if (vec[i].Item2 == i)  
        continue; 
    else
    { 
        
        // Swap with its respective index  
        Tuple<int, int> temp = vec[vec[i].Item2];
        vec[vec[i].Item2] = vec[i];
        vec[i] = temp;
    }  
    
    // Swap until the correct  
    // index matches 
    if (i != vec[i].Item2) 
        --i; 
      
    // Each swap makes one element 
    // move to its correct index,  
    // so increment answer 
    ans++; 
} 
return ans;

}

// Driver Code static void Main() { int[] arr = { 1, 5, 4, 3, 2 }; int n = arr.Length; 

Console.Write(findMinSwap(arr,n));

} }

// This code is contributed by divyeshrabadiya07

JavaScript

// JavaScript code for the above approach

function findMinSwap(arr, n) { // Declare a vector of pair
let vec = [];

for (let i = 0; i < n; i++) {
    vec.push([arr[i], i]);
}

// Sort the vector w.r.t the first
// element of pair
vec.sort(function (a, b) {
    return a[0] - b[0];
});

let ans = 0, c = 0;

for (let i = 0; i < n; i++) {
    // If the element is already placed
    // correct, then continue
    if (vec[i][1] == i) {
        continue;
    }
    else {
        // swap with its respective index 
        let t = vec[i][1]
        let c = vec[i][0]
        [vec[i][0], vec[t][0]] = [vec[t][0], vec[i][0]];
        [vec[i][1], vec[t][1]] = [vec[t][1], vec[i][1]];

    }

    // swap until the correct 
    // index matches
    if (i != vec[i][1])
        i--;

    // each swap makes one element
    // move to its correct index, 
    // so increment answer
    ans += 1;
}

return ans;

}

// Driver code let arr = [1, 5, 4, 3, 2];

let n = arr.length;

console.log(findMinSwap(arr, n));

// This code is contributed by poojaagarwal2.

`

Complexity Analysis: