归并排序的衍生问题之求数组中逆序对的数量

求数组中逆序对的数量是建立在归并排序算法基础上的衍生问题

还不是很懂归并排序算法的朋友，可以参考我的这篇博客

聊聊时间复杂度为O(nlogn)的归并排序（上）

 //利用merge思想求逆序对的个数
         // 递归求arr的逆序数对个数
         template<typename T>
         long long inversionCount(T arr[], int n)
         {

                return __inversionCount(arr, 0, n-1);
         }
         template<typename T>
         long long  __inversionCount(T arr, int l, int r)
         {
             long long  res1 = 0, res2 = 0;
             if(l >= r) return 0;
             int mid = (l + r) / 2;
             res1 = __inversionCount(arr, l, mid);  // 求出 arr[l...mid] 范围的逆序数
             res2 = __inversionCount(arr, mid + 1, r);  // 求出 arr[mid+1...r] 范围的逆序数
             return res1 + res2 + __inversionMerge(arr, l, mid, r);
         }
         // 计算逆序对的结果以 long long返回
         // 对于一个大小为N的数组，其最大的逆序对个数为 N *(N-1)/2，非常容易产生溢出

         //inversionMerge函数求出在arr[l, mid] 和arr[mid, r]有序的基础上，arr[l, r]的逆序对个数
         template<typename T>
         long long __inversionMerge(T arr[], int l, int m, int r)
         {
             T temp[r - l + 1];
             for(int i = l; i <= r; i++)
             {
                 temp[i - l] = arr[i];
             }
             int i = l, j = m + 1;
             long long  count = 0; //初始化逆序对个数为0
             for(int k = l; k <= r; k++)
             {
                 if(i > m)  // 如果左半部分元素已经全部处理完毕
                 {
                     arr[k] = temp[j - l];
                     j++;
                 }
                 else if(j > r)  // 如果右半部分元素已经全部处理完毕
                 {
                     arr[k] = temp[i - l];
                     i++;
                 }
                 else if(temp[i - l] < temp[j - l])  // 左半部分所指元素 <= 右半部分所指元素
                 {
                     arr[k] = arr[i - l];
                     i++;
                 }
                 else   // 右半部分所指元素 < 左半部分所指元素
                 {
                     arr[k] = arr[j - l];
                     j++;
                     // 此时, 因为右半部分k所指的元素小
                    // 这个元素和左半部分的所有未处理的元素都构成了逆序数对
                    // 左半部分此时未处理的元素个数为 mid - j + 1
                     count += (long long)(m - i + 1);
                 }
             }
             delete[] temp;
             return count;
         }