Check out example codes for "minimum swaps to sort an array". It will help you in understanding the concepts better.

Code Example 1

import java.io.*;
import java.math.*;
import java.util.*;

public class Swap {
	static int minimumSwaps(int[] arr) {
		int swap=0;
		boolean visited[]=new boolean[arr.length];

		for(int i=0;i<arr.length;i++){
			int j=i,cycle=0;

			while(!visited[j]){
				visited[j]=true;
				j=arr[j]-1;
				cycle++;
			}
			
			if(cycle!=0)
				swap+=cycle-1;
		}
		return swap;
	}

	public static void main(String[] args) {
		
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		int[] arr = new int[n];
		
		for (int i = 0; i < n; i++) {
			arr[i] = scanner.nextInt();
		}
		
		int res = minimumSwaps(arr);
		System.out.println(res);
		scanner.close();
	}
}

Code Example 2

# 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

Code Example 3

// C++ program to find  minimum number of swaps 
// required to sort an array 
#include<bits/stdc++.h> 
  
using namespace std; 
  
// Function returns the minimum number of swaps 
// required to sort the array 
int minSwaps(int arr[], int n) 
{ 
    // Create an array of pairs where first 
    // element is array element and second element 
    // is position of first element 
    pair<int, int> arrPos[n]; 
    for (int i = 0; i < n; i++) 
    { 
        arrPos[i].first = arr[i]; 
        arrPos[i].second = i; 
    } 
  
    // Sort the array by array element values to 
    // get right position of every element as second 
    // element of pair. 
    sort(arrPos, arrPos + n); 
  
    // To keep track of visited elements. Initialize 
    // all elements as not visited or false. 
    vector<bool> vis(n, false); 
  
    // Initialize result 
    int ans = 0; 
  
    // Traverse array elements 
    for (int i = 0; i < n; i++) 
    { 
        // already swapped and corrected or 
        // already present at correct pos 
        if (vis[i] || arrPos[i].second == i) 
            continue; 
  
        // find out the number of  node in 
        // this cycle and add in ans 
        int cycle_size = 0; 
        int j = i; 
        while (!vis[j]) 
        { 
            vis[j] = 1; 
  
            // move to next node 
            j = arrPos[j].second; 
            cycle_size++; 
        } 
  
        // Update answer by adding current cycle.  
        if (cycle_size > 0) 
        { 
            ans += (cycle_size - 1); 
        } 
    } 
  
    // Return result 
    return ans; 
} 
  
// Driver program to test the above function 
int main() 
{ 
    int arr[] = {1, 5, 4, 3, 2}; 
    int n = (sizeof(arr) / sizeof(int)); 
    cout << minSwaps(arr, n); 
    return 0; 
}

Code Example 4

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

Learn ReactJs, React Native from akashmittal.com