Java 数据结构

我正在编写一个程序，基本上是计算数组中的倒数。要求使用分治算法。 我使用了合并排序，但后来我卡住了。我需要创建另一个名为count的方法，以便使用递归计算反转。我需要你的帮助。。。 先谢谢你

    import java.util.*;

public class inversions
{
    public static void main(String[] args)
    {
        Integer[] a = {2, 6, 3, 5, 1};
        mergeSort(a);
        System.out.println(Arrays.toString(a));
    }

    public static void mergeSort(Comparable [ ] a)
    {
        Comparable[] tmp = new Comparable[a.length];
        mergeSort(a, tmp,  0,  a.length - 1);
    }


    private static void mergeSort(Comparable [ ] a, Comparable [ ] tmp, int left, int right)
    {
        if( left < right )
        {
            int center = (left + right) / 2;
            mergeSort(a, tmp, left, center);
            mergeSort(a, tmp, center + 1, right);
            merge(a, tmp, left, center + 1, right);
        }
    }


    private static void merge(Comparable[ ] a, Comparable[ ] tmp, int left, int right, int rightEnd )
    {
        int leftEnd = right - 1;
        int k = left;
        int num = rightEnd - left + 1;

        while(left <= leftEnd && right <= rightEnd)
            if(a[left].compareTo(a[right]) <= 0)
                tmp[k++] = a[left++];
            else
                tmp[k++] = a[right++];

        while(left <= leftEnd)    // Copy rest of first half
            tmp[k++] = a[left++];

        while(right <= rightEnd)  // Copy rest of right half
            tmp[k++] = a[right++];

        // Copy tmp back
        for(int i = 0; i < num; i++, rightEnd--)
            a[rightEnd] = tmp[rightEnd];
    }
    public int count(int[] A, int n){}

}

import java.util.*；
公共类倒置
{
公共静态void main（字符串[]args）
{
整数[]a={2,6,3,5,1}；
合并（a）；
System.out.println（Arrays.toString（a））；
}
公共静态无效合并排序（可比[]a）
{
可比[]tmp=新的可比[a.长度]；
合并排序（a，tmp，0，a.length-1）；
}
私有静态void合并排序（可比[]a，可比[]tmp，int left，int right）
{
if（左<右）
{
int center=（左+右）/2；
合并排序（a、tmp、左、中）；
合并排序（a，tmp，中间+1，右）；
合并（a、tmp、左、中+1、右）；
}
}
私有静态无效合并（可比[]a，可比[]tmp，int left，int right，int rightEnd）
{
int leftEnd=right-1；
int k=左；
int num=右端-左+1；
而（左在代码中添加了一些更改

import java.util.*;

public class inversions
{
    public static int countInversions = 0;
    public static void main(String[] args)
    {
        Integer[] a = {2, 6, 3, 5, 1};
        mergeSort(a);
        System.out.println(Arrays.toString(a));
        System.out.println(countInversions);
    }

    public static void mergeSort(Comparable [ ] a)
    {
        Comparable[] tmp = new Comparable[a.length];
        mergeSort(a, tmp,  0,  a.length - 1);
    }


    private static void mergeSort(Comparable [ ] a, Comparable [ ] tmp, int left, int right)
    {
        if( left < right )
        {
            int center = (left + right) / 2;
            mergeSort(a, tmp, left, center);
            mergeSort(a, tmp, center + 1, right);
            merge(a, tmp, left, center + 1, right);
        }
    }


    private static void merge(Comparable[ ] a, Comparable[ ] tmp, int left, int right, int rightEnd )
    {
        int leftEnd = right - 1;
        int k = left;
        int num = rightEnd - left + 1;

        while(left <= leftEnd && right <= rightEnd)
            if(a[left].compareTo(a[right]) <= 0)
                tmp[k++] = a[left++];
            else {
                countInversions+=((leftEnd-left)+1); // Counts the inversions
                tmp[k++] = a[right++];
            }

        while(left <= leftEnd)    // Copy rest of first half
            tmp[k++] = a[left++];

        while(right <= rightEnd)  // Copy rest of right half
            tmp[k++] = a[right++];

        // Copy tmp back
        for(int i = 0; i < num; i++, rightEnd--)
            a[rightEnd] = tmp[rightEnd];
    }
}

import java.util.*；
公共类倒置
{
公共静态整数倒数=0；
公共静态void main（字符串[]args）
{
整数[]a={2,6,3,5,1}；
合并（a）；
System.out.println（Arrays.toString（a））；
System.out.println（倒计时）；
}
公共静态无效合并排序（可比[]a）
{
可比[]tmp=新的可比[a.长度]；
合并排序（a，tmp，0，a.length-1）；
}
私有静态void合并排序（可比[]a，可比[]tmp，int left，int right）
{
if（左<右）
{
int center=（左+右）/2；
合并排序（a、tmp、左、中）；
合并排序（a，tmp，中间+1，右）；
合并（a、tmp、左、中+1、右）；
}
}
私有静态无效合并（可比[]a，可比[]tmp，int left，int right，int rightEnd）
{
int leftEnd=right-1；
int k=左；
int num=右端-左+1；
while（左）在执行合并排序时，您应该计算反转。每次，当您从第二个组中放入元素时（
索引>=right
），您将计数器增加1。@DmitryGinzburg更正：不是增加1，而是增加第一组中剩余的元素数？@DmitryGinzburg索引是什么？如果您想实现一个计算反转数的方法，您可以从方法中调用mergesort（）。