【算法学习】统计逆序数的个数

要求：

在一个排列中，如果一对数的前后位置与大小顺序相反，即前面的数大于后面的数，那么它们就称为一个逆序。一个排列中逆序的总数就称为这个排列的逆序数。

方法：

归并方法，将数组分为前后两短，统计数木后同时进行排序。例如，数列F(n)分为head和rear等长两部分，两部分都分别排过序。则总的逆序数，等于head部分的逆序数 + rear部分的逆序数，再加上逆序的两个数分别在head和rear这部分的数据。

CountAndSort(0, n) = CountAndSort(0, n/2) + CountAndSort(n/2 + 1, n) + 第三分部的值。

第三部分的数据，可以简单通过遍历来求取，E.g：

省略一些细节的，伪代码：

headIndex = 0;
readIndex = n/2 +1;
for (1:n)
{
  if (F(headIndex) > F(rearIndex))
  {
    此时为一个逆序。此时的rear的该点小于所有的该headIndex之后的点。
    因此逆序数需要加上  n/2 - headIndex + 1.
    将rearIndex放入排序后
    rearIndex++;
  }
  else
 {
  将headIndex放入排序后数组
  headIndex++
 }
}
此时排序后数组完成了对原数组的排序，刷新原数组。

代码：

#include "inver.h"
#include <vector>
#include <fstream>
#include <iostream>
#include <string>
using namespace std;
long long coutAll(long *array, long *buffer, long first, long last);
int main(char* arg[])
{
    ifstream inf("D:\\learn\\algorithem\\week2\\inver\\Big_IntegerArray.txt");
    if (!inf.is_open())
    {
        cout << "error" << endl;
    }
    string lineStr;
    std::vector<long> bigArrary;
    while (getline(inf, lineStr))
    {
        bigArrary.push_back(stol(lineStr));
    }
    
    long *array = new long[bigArrary.size()];
    long *arrayBuffer = new long[bigArrary.size()];
    for (long index = 0; index < bigArrary.size(); index++)
    {
        array[index] = bigArrary[index];
    }
    long long result = coutAll(array, arrayBuffer, 0, bigArrary.size() - 1);
    delete[] array;
    delete[] arrayBuffer;
    cout << "OK" << endl;
}

long long coutAll(long *array, long *buffer, long first, long last)
{
    if (first == last)
    {
        return 0;
    }
    const long mid = first + (last - first) / 2;
    const long mid2 = mid + 1;
    long long frontCount = coutAll(array, buffer, first, mid);
    long long endCount = coutAll(array, buffer, mid2, last);
    long firstIndex = first;
    long lastIndex = mid2;
    long long mixCount = 0;
    bool firstFinished = false;
    bool lastFinished = false;
    for (long index = first; index <= last; index++)
    {

        if (lastFinished || (!firstFinished &&  array[firstIndex] <= array[lastIndex]))
        {
            buffer[index] = array[firstIndex];
            if (firstIndex == mid)
            {
                firstFinished = true;
            }
            firstIndex++;
       }
        else
        {
            buffer[index] = array[lastIndex];
            if (lastIndex == last)
            {
                lastFinished = true;
            }
            mixCount += mid - firstIndex + 1;
            lastIndex++;
        }
    }
    memcpy(array + first, buffer + first, (last - first + 1) * sizeof(long));

    return mixCount + frontCount + endCount;
}