Related Articles

Related Articles

Minimum number of swaps required to sort an array of first N number
  • Difficulty Level : Medium
  • Last Updated : 24 Feb, 2020

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

#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

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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));
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Output:

3

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

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :