对前N个数字进行排序所需的最小交换次数

给定一个从1到N的不同整数的数组arr [] 。任务是找到对数组进行排序所需的最小交换次数。
例子：

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

方法：

• 对于arr []中的每个索引。
• 检查当前元素是否在正确的位置。由于数组包含从1到N的不同元素，因此我们可以简单地将元素与其在数组中的索引进行比较，以检查它是否在正确的位置。
• 如果当前元素不在其正确位置，则将其与已占据其位置的元素交换。
• 否则检查下一个索引。

下面是上述方法的实现：

C++

#include 
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

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

输出：

3

时间复杂度：O(N)，其中N是数组的大小。
辅助空间： O(1)