如何修复Java中的合并排序算法并从函数返回排序数组

我在Java中实现合并排序算法时遇到了一个问题：我已经完成了合并排序算法，但它不能产生正确的结果。我还从函数返回排序列表。我怎样才能做到呢

下面是我定义的合并排序算法

合并排序方法：

public static void mergeSort(ArrayList<Person> personList, Comparator<Person> compTr) {
    ArrayList<Person> helper = new ArrayList<Person>();
    mergeSort(personList, helper, 0, personList.size() - 1, compTr);
}

publicstaticvoidmergesort（arraylistpersonlist，comparatorcomptr）{
ArrayList助手=新建ArrayList（）；
mergeSort（personList，helper，0，personList.size（）-1，compTr）；
}

合并排序功能：

private static void mergeSort(ArrayList<Person> list, 
                              ArrayList<Person> helper, 
                              int low, 
                              int high, 
                              Comparator<Person> compTr) {
    if (low < high) {
        int middle = (low + high) / 2;
        mergeSort(list, helper, low, middle, compTr); //sort left half
        mergeSort(list, helper, middle + 1, high, compTr); //sort right half
        merge(list, helper, low, middle, high, compTr); // merge
    }
}

私有静态无效合并排序（ArrayList列表，
ArrayList助手，
int低，
int高，
比较器（compTr）{
如果（低<高）{
int-middle=（低+高）/2；
mergeSort（list，helper，low，middle，compTr）；//对左半部分进行排序
mergeSort（list，helper，middle+1，high，compTr）；//对右半部分进行排序
合并（列表，辅助对象，低，中，高，compTr）；//合并
}
}

合并算法：

private static void merge(ArrayList<Person> list, 
                          ArrayList<Person> helper, 
                          int low, 
                          int middle, 
                          int high,
                          Comparator<Person> compTr) {
    //This loop throws Exception
    for (int i = low; i < high + 1; i++) {
        helper.add(i, list.get(i));
    }

    int helperLeft = low;
    int helperRight = middle + 1;
    int current = low;

    while (helperLeft < middle && helperRight < high) {
        if (isGreaterThan(helper.get(helperLeft), helper.get(helperRight), compTr)) {
            list.set(current, helper.get(helperLeft));
            helperLeft++;
        } else {
            list.set(current, helper.get(helperRight));
            helperRight++;
        }
        current++;
    }

    //Copy remaining elements
    int remaining = middle - helperLeft;
    for (int j = 0; j <= remaining; j++) {
        list.set(current + j, helper.get(helperLeft + j));
    }

    // RETURN LIST(list) _-> TO DO 
}

私有静态无效合并（ArrayList列表，
ArrayList助手，
int低，
int中间，
int高，
比较器（compTr）{
//此循环引发异常
对于（int i=低；i<高+1；i++）{
add（i，list.get（i））；
}
int helperLeft=低；
int helperRight=中间+1；
int电流=低；
while（helperLeft

实现比较器特性

public static boolean isGreaterThan(Person helperLeft, Person helperRight, Comparator<Person> compTr) {
    return greaterThan(compTr, helperLeft, helperRight);
}

private static boolean greaterThan(Comparator comp, Person x, Person y) {
    return comp.compare(x, y) > 0;
}

公共静态布尔值大于（Person helperLeft、Person helperRight、Comparator compTr）{
返回值大于（compTr、helperLeft、helperRight）；
}
私有静态布尔值大于（比较器comp，Person x，Person y）{
返回组件比较（x，y）>0；
}

我该怎么做

我无法从合并函数中获取作为列表的返回值

如果我理解正确，您正在寻找返回已排序列表的方法。但在您的实现中，您正在尝试对原始列表进行排序。
这意味着您在调用merge函数时已经有了一个指向结果排序列表的变量：调用merge函数时用作参数的变量

public static void mergeSort(ArrayList<Person> personList, Comparator<Person> compTr)

publicstaticvoidmergesort（arraylistpersonlist，comparatorcomptr）

例如，如果您的人员位于名为“列表”的ArrayList中，则您正在对该“列表”进行排序

ArrayList list=new ArrayList（）；
对于（int i=0；i<10；i++）{
list.add（newperson（））；
}
系统输出打印项次（列表）；
mergeSort（list，Comparator.naturalOrder（））；
系统输出打印项次（列表）；

关于更多信息，您使用的是一个inout参数——例如，您将输入输入给函数，并通过该参数接收其输出

---

正如注释中指出的，代码还有其他问题。我怀疑这里有一个错误（这是我的答案

我改了密码

 while(helperLeft < middle && helperRight < high) {

while（helperLeft

到

while（helperLeft无需返回已排序的数组：数组已排序到位

但请注意这些问题：


＞P>辅助数组应该分配一个初始大小等于要排序的数组的大小。这避免了<代码>帮助器的问题。添加（i，List.GET（i））；保持“强”>插入“< /强”>辅助数组中间的额外元素。这是非常低效的：它要求<强> O（n*log（n））。额外的空间，而不仅仅是O（n）并且具有O（nnlog（n））的时间复杂度，这比插入排序更糟糕

您将使用

  ArrayList<Person> helper = new ArrayList<Person>(personList);



包含上界的惯例令人困惑且容易出错，排除上界要简单得多，因为它消除了
-1
/
+1
调整的需要

以下是修改后的版本：

publicstaticvoidmergesort（arraylistpersonlist，comparatorcomptr）{
ArrayList助手=新的ArrayList（personList）；
mergeSort（personList，helper，0，personList.size（），compTr）；
}
私有静态void合并排序（ArrayList列表，
ArrayList助手，
int低，
int高，
比较器（compTr）{
如果（高-低>=2）{
int middle=低+（高-低）/2；
mergeSort（list，helper，low，middle，compTr）；//对左半部分进行排序
mergeSort（list，helper，middle，high，compTr）；//对右半部分进行排序
合并（列表，辅助对象，低，中，高，compTr）；//合并
}
}
私有静态无效合并（ArrayList，
ArrayList助手，
int低，
int中间，
int高，
比较器（compTr）{
对于（int i=低；i<高；i++）{
set（i，list.get（i））；
}
int helperLeft=低；
int helperRight=中间；
int电流=低；
while（helperLeft while(helperLeft < middle && helperRight < high) {

 while(helperLeft <= middle && helperRight <= high) {

  ArrayList<Person> helper = new ArrayList<Person>(personList);

  while (helperLeft <= middle && helperRight <= high)