仅允许相邻交换时要排序的交换数

给定非负整数的数组arr []。我们可以对数组中的任何两个相邻元素执行交换操作。查找按升序对数组进行排序所需的最小交换次数。
例子 ：

Input  : arr[] = {3, 2, 1}
Output : 3
We need to do following swaps
(3, 2), (3, 1) and (1, 2)

Input  : arr[] = {1, 20, 6, 4, 5}
Output : 5

)

这个问题有一个有趣的解决方案。可以使用以下事实来解决：所需交换次数等于反转次数。因此，我们基本上需要计算数组中的反转数。
可以使用以下观察来确定事实：
1)排序的数组没有反转。
2)相邻交换可以减少一个反转。进行x个相邻的交换可以减少数组中的x个反转。

C++

// C++ program to count number of swaps required
// to sort an array when only swapping of adjacent
// elements is allowed.
#include 
 
/* This function merges two sorted arrays and returns inversion
   count in the arrays.*/
int merge(int arr[], int temp[], int left, int mid, int right)
{
    int inv_count = 0;
 
    int i = left; /* i is index for left subarray*/
    int j = mid;  /* i is index for right subarray*/
    int k = left; /* i is index for resultant merged subarray*/
    while ((i <= mid - 1) && (j <= right))
    {
        if (arr[i] <= arr[j])
            temp[k++] = arr[i++];
        else
        {
            temp[k++] = arr[j++];
 
            /* this is tricky -- see above explanation/
              diagram for merge()*/
            inv_count = inv_count + (mid - i);
        }
    }
 
    /* Copy the remaining elements of left subarray
     (if there are any) to temp*/
    while (i <= mid - 1)
        temp[k++] = arr[i++];
 
    /* Copy the remaining elements of right subarray
     (if there are any) to temp*/
    while (j <= right)
        temp[k++] = arr[j++];
 
    /*Copy back the merged elements to original array*/
    for (i=left; i <= right; i++)
        arr[i] = temp[i];
 
    return inv_count;
}
 
/* An auxiliary recursive function that sorts the input
   array and returns the number of inversions in the
   array. */
int _mergeSort(int arr[], int temp[], int left, int right)
{
    int mid, inv_count = 0;
    if (right > left)
    {
        /* Divide the array into two parts and call
          _mergeSortAndCountInv() for each of the parts */
        mid = (right + left)/2;
 
        /* Inversion count will be sum of inversions in
           left-part, right-part and number of inversions
           in merging */
        inv_count  = _mergeSort(arr, temp, left, mid);
        inv_count += _mergeSort(arr, temp, mid+1, right);
 
        /*Merge the two parts*/
        inv_count += merge(arr, temp, left, mid+1, right);
    }
 
    return inv_count;
}
 
/* This function sorts the input array and returns the
   number of inversions in the array */
int countSwaps(int arr[], int n)
{
    int temp[n];
    return _mergeSort(arr, temp, 0, n - 1);
}
 
/* Driver progra to test above functions */
int main(int argv, char** args)
{
    int arr[] = {1, 20, 6, 4, 5};
    int n = sizeof(arr)/sizeof(arr[0]);
    printf("Number of swaps is %d \n", countSwaps(arr, n));
    return 0;
}

Java

// Java program to count number of
// swaps required to sort an array
// when only swapping of adjacent
// elements is allowed.
import java.io.*;
 
class GFG {
     
// This function merges two sorted
// arrays and returns inversion
// count in the arrays.
static int merge(int arr[], int temp[],
            int left, int mid, int right)
{
    int inv_count = 0;
 
    /* i is index for left subarray*/
    int i = left;
     
    /* i is index for right subarray*/
    int j = mid;
     
    /* i is index for resultant merged subarray*/
    int k = left;
     
    while ((i <= mid - 1) && (j <= right))
    {
        if (arr[i] <= arr[j])
            temp[k++] = arr[i++];
        else
        {
            temp[k++] = arr[j++];
 
            /* this is tricky -- see above /
             explanation diagram for merge()*/
            inv_count = inv_count + (mid - i);
        }
    }
 
    /* Copy the remaining elements of left
    subarray (if there are any) to temp*/
    while (i <= mid - 1)
        temp[k++] = arr[i++];
 
    /* Copy the remaining elements of right
    subarray (if there are any) to temp*/
    while (j <= right)
        temp[k++] = arr[j++];
 
    /*Copy back the merged elements
    to original array*/
    for (i=left; i <= right; i++)
        arr[i] = temp[i];
 
    return inv_count;
}
 
// An auxiliary recursive function that
// sorts the input array and returns
// the number of inversions in the array.
static int _mergeSort(int arr[], int temp[],
                         int left, int right)
{
    int mid, inv_count = 0;
    if (right > left)
    {
        // Divide the array into two parts and
        // call _mergeSortAndCountInv() for
        // each of the parts
        mid = (right + left)/2;
 
        /* Inversion count will be sum of
        inversions in left-part, right-part
        and number of inversions in merging */
        inv_count = _mergeSort(arr, temp,
                                left, mid);
                                 
        inv_count += _mergeSort(arr, temp,
                                mid+1, right);
 
        /*Merge the two parts*/
        inv_count += merge(arr, temp,
                        left, mid+1, right);
    }
 
    return inv_count;
}
 
// This function sorts the input
// array and returns the number
// of inversions in the array
static int countSwaps(int arr[], int n)
{
    int temp[] = new int[n];
    return _mergeSort(arr, temp, 0, n - 1);
}
 
// Driver Code
public static void main (String[] args)
{
 
    int arr[] = {1, 20, 6, 4, 5};
    int n = arr.length;
        System.out.println("Number of swaps is "
                           + countSwaps(arr, n));
    }
}
 
// This code is contributed by vt_m

Python3

# python 3 program to count number of swaps required
# to sort an array when only swapping of adjacent
# elements is allowed.
#include 
 
#This function merges two sorted arrays and returns inversion count in the arrays.*/
def merge(arr, temp, left, mid, right):
    inv_count = 0
 
    i = left #i is index for left subarray*/
    j = mid #i is index for right subarray*/
    k = left #i is index for resultant merged subarray*/
    while ((i <= mid - 1) and (j <= right)):
        if (arr[i] <= arr[j]):
            temp[k] = arr[i]
            k += 1
            i += 1
        else:
            temp[k] = arr[j]
            k += 1
            j += 1
 
            #this is tricky -- see above explanation/
            # diagram for merge()*/
            inv_count = inv_count + (mid - i)
 
    #Copy the remaining elements of left subarray
    # (if there are any) to temp*/
    while (i <= mid - 1):
        temp[k] = arr[i]
        k += 1
        i += 1
 
    #Copy the remaining elements of right subarray
    # (if there are any) to temp*/
    while (j <= right):
        temp[k] = arr[j]
        k += 1
        j += 1
 
    # Copy back the merged elements to original array*/
    for i in range(left,right+1,1):
        arr[i] = temp[i]
 
    return inv_count
 
#An auxiliary recursive function that sorts the input
# array and returns the number of inversions in the
# array. */
def _mergeSort(arr, temp, left, right):
    inv_count = 0
    if (right > left):
        # Divide the array into two parts and call
        #_mergeSortAndCountInv()
        # for each of the parts */
        mid = int((right + left)/2)
 
        #Inversion count will be sum of inversions in
        # left-part, right-part and number of inversions
        # in merging */
        inv_count = _mergeSort(arr, temp, left, mid)
        inv_count += _mergeSort(arr, temp, mid+1, right)
 
        # Merge the two parts*/
        inv_count += merge(arr, temp, left, mid+1, right)
 
    return inv_count
 
#This function sorts the input array and returns the
#number of inversions in the array */
def countSwaps(arr, n):
    temp = [0 for i in range(n)]
    return _mergeSort(arr, temp, 0, n - 1)
 
# Driver progra to test above functions */
if __name__ == '__main__':
    arr = [1, 20, 6, 4, 5]
    n = len(arr)
    print("Number of swaps is",countSwaps(arr, n))
     
 
# This code is contributed by
# Surendra_Gangwar

C#

// C# program to count number of
// swaps required to sort an array
// when only swapping of adjacent
// elements is allowed.
using System;
 
class GFG
{
     
// This function merges two
// sorted arrays and returns
// inversion count in the arrays.
static int merge(int []arr, int []temp,
                 int left, int mid,
                 int right)
{
    int inv_count = 0;
 
    /* i is index for
    left subarray*/
    int i = left;
     
    /* i is index for
    right subarray*/
    int j = mid;
     
    /* i is index for resultant
    merged subarray*/
    int k = left;
     
    while ((i <= mid - 1) &&
           (j <= right))
    {
        if (arr[i] <= arr[j])
            temp[k++] = arr[i++];
        else
        {
            temp[k++] = arr[j++];
 
            /* this is tricky -- see above /
            explanation diagram for merge()*/
            inv_count = inv_count + (mid - i);
        }
    }
 
    /* Copy the remaining elements
    of left subarray (if there are
    any) to temp*/
    while (i <= mid - 1)
        temp[k++] = arr[i++];
 
    /* Copy the remaining elements
    of right subarray (if there are
    any) to temp*/
    while (j <= right)
        temp[k++] = arr[j++];
 
    /*Copy back the merged
    elements to original array*/
    for (i=left; i <= right; i++)
        arr[i] = temp[i];
 
    return inv_count;
}
 
// An auxiliary recursive function
// that sorts the input array and
// returns the number of inversions
// in the array.
static int _mergeSort(int []arr, int []temp,
                      int left, int right)
{
    int mid, inv_count = 0;
    if (right > left)
    {
        // Divide the array into two parts
        // and call _mergeSortAndCountInv()
        // for each of the parts
        mid = (right + left) / 2;
 
        /* Inversion count will be sum of
        inversions in left-part, right-part
        and number of inversions in merging */
        inv_count = _mergeSort(arr, temp,
                               left, mid);
                                 
        inv_count += _mergeSort(arr, temp,
                                mid + 1, right);
 
        /*Merge the two parts*/
        inv_count += merge(arr, temp,
                           left, mid + 1, right);
    }
 
    return inv_count;
}
 
// This function sorts the input
// array and returns the number
// of inversions in the array
static int countSwaps(int []arr, int n)
{
    int []temp = new int[n];
    return _mergeSort(arr, temp, 0, n - 1);
}
 
// Driver Code
public static void Main ()
{
 
    int []arr = {1, 20, 6, 4, 5};
    int n = arr.Length;
        Console.Write("Number of swaps is " +
                         countSwaps(arr, n));
    }
}
 
// This code is contributed by nitin mittal.

PHP

 $left)
    {
        /* Divide the array into two parts and call
          _mergeSortAndCountInv() for each of the parts */
        $mid = intval(($right + $left)/2);
  
        /* Inversion count will be sum of inversions in
           left-part, right-part and number of inversions
           in merging */
        $inv_count  = _mergeSort($arr, $temp, $left, $mid);
        $inv_count += _mergeSort($arr, $temp, $mid+1, $right);
  
        /*Merge the two parts*/
        $inv_count += merge($arr, $temp, $left, $mid+1, $right);
    }
  
    return $inv_count;
}
  
/* This function sorts the input array and returns the
   number of inversions in the array */
function countSwaps(&$arr, $n)
{
    $temp = array_fill(0,$n,NULL);
    return _mergeSort($arr, $temp, 0, $n - 1);
}
  
/* Driver progra to test above functions */
 
$arr = array(1, 20, 6, 4, 5);
$n = sizeof($arr)/sizeof($arr[0]);
echo "Number of swaps is ". countSwaps($arr, $n);
return 0;
?>

Javascript

// Javascript program to count number of
// swaps required to sort an array
// when only swapping of adjacent
// elements is allowed.
     
    // This function merges two sorted
    // arrays and returns inversion
    // count in the arrays.
    function merge(arr,temp,left,mid,right)
    {
         let inv_count = 0;
   
        /* i is index for left subarray*/
        let i = left;
           
        /* i is index for right subarray*/
        let j = mid;
           
        /* i is index for resultant merged subarray*/
        let k = left;
           
        while ((i <= mid - 1) && (j <= right))
        {
            if (arr[i] <= arr[j])
                temp[k++] = arr[i++];
            else
            {
                temp[k++] = arr[j++];
       
                /* this is tricky -- see above /
                 explanation diagram for merge()*/
                inv_count = inv_count + (mid - i);
            }
        }
       
        /* Copy the remaining elements of left
        subarray (if there are any) to temp*/
        while (i <= mid - 1)
            temp[k++] = arr[i++];
       
        /* Copy the remaining elements of right
        subarray (if there are any) to temp*/
        while (j <= right)
            temp[k++] = arr[j++];
       
        /*Copy back the merged elements
        to original array*/
        for (i=left; i <= right; i++)
            arr[i] = temp[i];
       
        return inv_count;
    }
     
    // An auxiliary recursive function that
    // sorts the input array and returns
    // the number of inversions in the array.
    function _mergeSort(arr,temp,left,right)
    {
        let mid, inv_count = 0;
        if (right > left)
        {
            // Divide the array into two parts and
            // call _mergeSortAndCountInv() for
            // each of the parts
            mid = Math.floor((right + left)/2);
       
            /* Inversion count will be sum of
            inversions in left-part, right-part
            and number of inversions in merging */
            inv_count = _mergeSort(arr, temp,
                                    left, mid);
                                       
            inv_count += _mergeSort(arr, temp,
                                    mid+1, right);
       
            /*Merge the two parts*/
            inv_count += merge(arr, temp,
                            left, mid+1, right);
        }
       
        return inv_count;
    }
     
    // This function sorts the input
    // array and returns the number
    // of inversions in the array
    function countSwaps(arr,n)
    {
        let temp = new Array(n);
        for(let i = 0; i < n; i++)
        {
            temp[i] = 0;
        }
        return _mergeSort(arr, temp, 0, n - 1);
    }
     
    // Driver Code
    let arr=[1, 20, 6, 4, 5];
    let n = arr.length;
    document.write("Number of swaps is "
                           + countSwaps(arr, n));
                            
    // This code is contributed by rag2127

输出 ：

Number of swaps is 5