Сортировка слиянием: подсчитать количество перестановок

#include <stdio.h>
#include <conio.h>
 
void Merge(int *A, int first, int last)
{
    int middle, start, final, j;
    int *mas=new int[last];
    middle = (first + last) / 2;
    start = first;
    final = middle + 1;
    for (j = first; j <= last; j++)
    {
        if ((start <= middle) && ((final>last) || (A[start]<A[final])))
        {
            mas[j] = A[start];
            start++;
        }
        else
        {
            mas[j] = A[final];
            final++;
        }
    }
    for (j = first; j <= last; j++)
    {
        A[j] = mas[j];
    }
    delete[]mas;
}
void MergeSort(int *A, int first, int last)
{
    if (first<last)
    {
        MergeSort(A, first, (first + last) / 2);
        MergeSort(A, (first + last) / 2 + 1, last);
        Merge(A, first, last);
    }
}
int main()
{
    int i, n;
    
    scanf("%d", &n);
    int *A = new int[n];
 
    for (i = 0; i < n; i++)
    {
        scanf("%d", &A[i]);
    }
 
    MergeSort(A, 1, n);
     
    for (i = 0; i < n; i++)
    {
        printf("%d", A[i]);
    }
    delete[]A;
    
    getch();
 
    return 0;
}

template<class T> void Merge(T const *const A, int const nA,
                             T const *const B, int const nB,
                             T *const C)
{ //Выполнить слияние массива A, содержащего nA элементов,
  //  и массива B, содержащего nB элементов.
  //  Результат записать в массив C.
 
    int a(0), b(0); //Номера текущих элементов в массивах A и B
 
    while( a+b < nA+nB ) //Пока остались элементы в массивах
    {
        if( (b>=nB) || ( (a<nA) && (A[a]<=B[b]) ) )
        { //Копирую элемент из массива A
            C[a+b] = A[a];
            ++a;
        } else { //Копирую элемент из массива B
            C[a+b] = B[b];
            ++b;
        }
    }
}

template<class T> void MergeSort(T *const A, int const n)
{ //Отсортировать массив A, содержащий n элементов
 
    if( n < 2 ) return; //Сортировка не нужна
 
    if( n == 2 ) //Два элемента проще поменять местами,
    {            //  если нужно, чем делать слияние
        if( A[0] > A[1] ) { T const t(A[0]); A[0]=A[1]; A[1]=t; }
        return;
    }
   
    MergeSort(A    , n/2  ); //Сортируем первую половину
    MergeSort(A+n/2, n-n/2); //Сортируем вторую половину
 
    T *const B( new T[n] ); //Сюда запишем результат слияния
 
    Merge(A,n/2, A+n/2,n-n/2, B); //Слияние половин
 
    //Копирование результата слияния в исходный массив:
    for(int i(0); i<n; ++i) A[i]=B[i];
 
    delete[n] B; //Удаляем временный буфер
}

 Merge(A,n/2, A+n/2,n-n/2, B);