Skip to content
Related Articles

Related Articles

Minimum number of swaps required to sort an array of first N number
  • Difficulty Level : Medium
  • Last Updated : 20 Apr, 2021

Given an array arr[] of distinct integers from 1 to N. The task is to find the minimum number of swaps required to sort the array. 
Example: 
 

Input: arr[] = { 7, 1, 3, 2, 4, 5, 6 }
Output: 5
Explanation:
i           arr             swap (indices)
0   [7, 1, 3, 2, 4, 5, 6]   swap (0, 3)
1   [2, 1, 3, 7, 4, 5, 6]   swap (0, 1)
2   [1, 2, 3, 7, 4, 5, 6]   swap (3, 4)
3   [1, 2, 3, 4, 7, 5, 6]   swap (4, 5)
4   [1, 2, 3, 4, 5, 7, 6]   swap (5, 6)
5   [1, 2, 3, 4, 5, 6, 7]
Therefore, total number of swaps = 5

Input: arr[] = { 2, 3, 4, 1, 5 }
Output: 3

 

Approach: 
 

  • For each index in arr[].
  • Check if the current element is in it’s right position or not. Since the array contains distinct elements from 1 to N, we can simply compare the element with it’s index in array to check if it is at its right position.
  • If current element is not at it’s right position then swap the element with the element which has occupied its place.
  • Else check for next index.

Below is the implementation of the above approach: 
 

C++




#include <iostream>
using namespace std;
 
// Function to find minimum swaps
int minimumSwaps(int arr[],int n)
{
    // Initialise count variable
    int count = 0;
    int i = 0;
     
    while (i < n)
    {
 
        // If current element is
        // not at the right position
        if (arr[i] != i + 1)
        {
 
            while (arr[i] != i + 1)
            {
                int temp = 0;
 
                // Swap current element
                // with correct position
                // of that element
                temp = arr[arr[i] - 1];
                arr[arr[i] - 1] = arr[i];
                arr[i] = temp;
                count++;
            }
        }
 
        // Increment for next index
        // when current element is at
        // correct position
        i++;
    }
    return count;
}
 
// Driver code
int main()
{
    int arr[] = { 2, 3, 4, 1, 5 };
 
    int n = sizeof(arr)/sizeof(arr[0]);
     
    // Function to find minimum swaps
    cout << minimumSwaps(arr,n) ;
}
 
// This code is contributed by AnkitRai01

Java




// Java program to find the minimum
// number of swaps required to sort
// the given array
import java.io.*;
import java.util.*;
 
class GfG {
 
    // Function to find minimum swaps
    static int minimumSwaps(int[] arr)
    {
        // Initialise count variable
        int count = 0;
        int i = 0;
        while (i < arr.length) {
 
            // If current element is
            // not at the right position
            if (arr[i] != i + 1) {
 
                while (arr[i] != i + 1) {
                    int temp = 0;
 
                    // Swap current element
                    // with correct position
                    // of that element
                    temp = arr[arr[i] - 1];
                    arr[arr[i] - 1] = arr[i];
                    arr[i] = temp;
                    count++;
                }
            }
 
            // Increment for next index
            // when current element is at
            // correct position
            i++;
        }
        return count;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 2, 3, 4, 1, 5 };
 
        // Function to find minimum swaps
        System.out.println(minimumSwaps(arr));
    }
}

Python3




# Python3 program to find the minimum
# number of swaps required to sort
# the given array
 
# Function to find minimum swaps
def minimumSwaps(arr):
     
    # Initialise count variable
    count = 0;
    i = 0;
    while (i < len(arr)):
 
        # If current element is
        # not at the right position
        if (arr[i] != i + 1):
 
            while (arr[i] != i + 1):
                temp = 0;
 
                # Swap current element
                # with correct position
                # of that element
                temp = arr[arr[i] - 1];
                arr[arr[i] - 1] = arr[i];
                arr[i] = temp;
                count += 1;
             
        # Increment for next index
        # when current element is at
        # correct position
        i += 1;
     
    return count;
 
# Driver code
if __name__ == '__main__':
    arr = [ 2, 3, 4, 1, 5 ];
 
    # Function to find minimum swaps
    print(minimumSwaps(arr));
     
# This code is contributed by 29AjayKumar

C#




// C# program to find the minimum
// number of swaps required to sort
// the given array
using System;
 
class GfG
{
 
    // Function to find minimum swaps
    static int minimumSwaps(int[] arr)
    {
        // Initialise count variable
        int count = 0;
        int i = 0;
        while (i < arr.Length)
        {
 
            // If current element is
            // not at the right position
            if (arr[i] != i + 1)
            {
 
                while (arr[i] != i + 1)
                {
                    int temp = 0;
 
                    // Swap current element
                    // with correct position
                    // of that element
                    temp = arr[arr[i] - 1];
                    arr[arr[i] - 1] = arr[i];
                    arr[i] = temp;
                    count++;
                }
            }
 
            // Increment for next index
            // when current element is at
            // correct position
            i++;
        }
        return count;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int []arr = { 2, 3, 4, 1, 5 };
 
        // Function to find minimum swaps
        Console.WriteLine(minimumSwaps(arr));
    }
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
 
// javascipt program to find the minimum
// number of swaps required to sort
// the given array
 
// Function to find minimum swaps
function minimumSwaps(arr)
{
    // Initialise count variable
    let count = 0;
    let i = 0;
    while (i < arr.length)
    {
 
        // If current element is
        // not at the right position
        if (arr[i] != i + 1)
        {
 
            while (arr[i] != i + 1)
            {
                let temp = 0;
 
                // Swap current element
                // with correct position
                // of that element
                temp = arr[arr[i] - 1];
                arr[arr[i] - 1] = arr[i];
                arr[i] = temp;
                count++;
            }
        }
 
        // Increment for next index
        // when current element is at
        // correct position
        i++;
    }
    return count;
}
 
// Driver code
 
let arr = [2, 3, 4, 1, 5 ];
 
// Function to find minimum swaps
document.write(minimumSwaps(arr));
 
 
</script>
Output: 
3

 

Time Complexity: O(N) where N is the size of array. 
Auxiliary Space: O(1)
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :