Java中的简单合并排序

我试图在Java中创建一个简单的合并排序程序。我觉得它应该可以工作，但当我去运行它时，我得到一个堆栈溢出错误：

Stack overflow at MergeSort.mergeSort(MergeSort.java:24)

我在这里看到其他几个人也有类似的代码问题，但我正在努力解决我的问题。任何帮助都将不胜感激

主要代码：

导入静态java.lang.System.*；
导入java.util.array；
公共类合并排序{
私有静态整数密码；
公共静态无效合并排序（可比[]列表）
{
passCount=0；
合并排序（list，0，list.length）；
}
私有静态void mergeSort（可比较的[]列表，int-front，int-back）//O（Log N）
{
int mid=（前+后）/2；
如果（中间==前部）
返回；
合并排序（列表、前、中）；
合并排序（列表、前、后）；
合并（列表、前、后）；
}
私有静态void merge（可比较的[]列表，int-front，int-back）//O（N）
{
可比[]温度=新可比[后-前]；
int i=前部；
int j=（前+后）/2；
int k=0；
int mid=j；
而（i

我的跑步者：

公共类合并SortRunner
{
公共静态void main（字符串参数[]）
{
MergeSort.MergeSort（新的可比较[]{9,5,3,2}）；
System.out.println（“\n”）；
MergeSort.MergeSort（新的可比[]{19,52,3,2,7,21}）；
System.out.println（“\n”）；
MergeSort.MergeSort（新的可比[]{68,66,11,2,42,31}）；
System.out.println（“\n”）；
}
}

尝试更改

if(mid==front) return;

到

if（后-前尝试更改

if(mid==front) return;

到

if（后-前尝试更改

if(mid==front) return;

到

if（后-前尝试更改

if(mid==front) return;

到

if（back-front您需要更改：

mergeSort(list, front, back);

if(mid==front) return;

致：

这将导致对
mergeSort
的无限调用，因为您不会在调用之间更改任何输入参数

您可能还想更改：

mergeSort(list, front, back);

if(mid==front) return;

致：

if（back-front您需要更改：

mergeSort(list, front, back);

if(mid==front) return;

致：

这将导致对
mergeSort
的无限调用，因为您不会在调用之间更改任何输入参数

您可能还想更改：

mergeSort(list, front, back);

if(mid==front) return;

致：

if（back-front您需要更改：

mergeSort(list, front, back);

if(mid==front) return;

致：

这将导致对
mergeSort
的无限调用，因为您不会在调用之间更改任何输入参数

您可能还想更改：

mergeSort(list, front, back);

if(mid==front) return;

致：

if（back-front您需要更改：

mergeSort(list, front, back);

if(mid==front) return;

致：

这将导致对
mergeSort
的无限调用，因为您不会在调用之间更改任何输入参数

您可能还想更改：

mergeSort(list, front, back);

if(mid==front) return;

致：

if（back-front我知道这真的很晚了，但是我有你想要的正确答案

import static java.lang.System.*;
import java.util.Arrays;        

public class MergeSort{

private static int passCount;

public static void mergeSort(int[] list)
{
    passCount=0;
    mergeSort(list, 0, list.length);
}

private static void mergeSort(int[] list, int front, int back)  //O( Log N )
{
    int mid = (front+back)/2;
    if(mid==front) return;
    mergeSort(list, front, mid);
    mergeSort(list, mid, back);
    merge(list, front, back);

}

private static void merge(int[] list, int front, int back)  //O(N)
{
   int dif = back-front;
   int[] temp = new int[dif];
   int beg = front, mid = (front+back)/2;
   int saveMid = mid;
   int spot = 0;

   while(beg < saveMid && mid < back) {
      if(list[beg] < list[mid]) {
         temp[spot++] = list[beg++];
      } else {
         temp[spot++] = list[mid++];
      }
   }
   while(beg < saveMid)
      temp[spot++] = list[beg++];
   while(mid < back)
      temp[spot++] = list[mid++];
   for(int i = 0; i < back-front; i++) {
      list[front+i] = temp[i];
   }
    System.out.println("pass " + passCount++ + " " + Arrays.toString(list) + "\n");
  }
 }

事实证明，使用while循环在列表中循环可以帮助您返回正确的值！
我知道这真的太晚了，但我有您想要的正确答案

import static java.lang.System.*;
import java.util.Arrays;        

public class MergeSort{

private static int passCount;

public static void mergeSort(int[] list)
{
    passCount=0;
    mergeSort(list, 0, list.length);
}

private static void mergeSort(int[] list, int front, int back)  //O( Log N )
{
    int mid = (front+back)/2;
    if(mid==front) return;
    mergeSort(list, front, mid);
    mergeSort(list, mid, back);
    merge(list, front, back);

}

private static void merge(int[] list, int front, int back)  //O(N)
{
   int dif = back-front;
   int[] temp = new int[dif];
   int beg = front, mid = (front+back)/2;
   int saveMid = mid;
   int spot = 0;

   while(beg < saveMid && mid < back) {
      if(list[beg] < list[mid]) {
         temp[spot++] = list[beg++];
      } else {
         temp[spot++] = list[mid++];
      }
   }
   while(beg < saveMid)
      temp[spot++] = list[beg++];
   while(mid < back)
      temp[spot++] = list[mid++];
   for(int i = 0; i < back-front; i++) {
      list[front+i] = temp[i];
   }
    System.out.println("pass " + passCount++ + " " + Arrays.toString(list) + "\n");
  }
 }

事实证明，使用while循环在列表中循环可以帮助您返回正确的值！
我知道这真的太晚了，但我有您想要的正确答案

import static java.lang.System.*;
import java.util.Arrays;        

public class MergeSort{

private static int passCount;

public static void mergeSort(int[] list)
{
    passCount=0;
    mergeSort(list, 0, list.length);
}

private static void mergeSort(int[] list, int front, int back)  //O( Log N )
{
    int mid = (front+back)/2;
    if(mid==front) return;
    mergeSort(list, front, mid);
    mergeSort(list, mid, back);
    merge(list, front, back);

}

private static void merge(int[] list, int front, int back)  //O(N)
{
   int dif = back-front;
   int[] temp = new int[dif];
   int beg = front, mid = (front+back)/2;
   int saveMid = mid;
   int spot = 0;

   while(beg < saveMid && mid < back) {
      if(list[beg] < list[mid]) {
         temp[spot++] = list[beg++];
      } else {
         temp[spot++] = list[mid++];
      }
   }
   while(beg < saveMid)
      temp[spot++] = list[beg++];
   while(mid < back)
      temp[spot++] = list[mid++];
   for(int i = 0; i < back-front; i++) {
      list[front+i] = temp[i];
   }
    System.out.println("pass " + passCount++ + " " + Arrays.toString(list) + "\n");
  }
 }

事实证明，使用while循环在列表中循环可以帮助您返回正确的值！
我知道这真的太晚了，但我有您想要的正确答案

import static java.lang.System.*;
import java.util.Arrays;        

public class MergeSort{

private static int passCount;

public static void mergeSort(int[] list)
{
    passCount=0;
    mergeSort(list, 0, list.length);
}

private static void mergeSort(int[] list, int front, int back)  //O( Log N )
{
    int mid = (front+back)/2;
    if(mid==front) return;
    mergeSort(list, front, mid);
    mergeSort(list, mid, back);
    merge(list, front, back);

}

private static void merge(int[] list, int front, int back)  //O(N)
{
   int dif = back-front;
   int[] temp = new int[dif];
   int beg = front, mid = (front+back)/2;
   int saveMid = mid;
   int spot = 0;

   while(beg < saveMid && mid < back) {
      if(list[beg] < list[mid]) {
         temp[spot++] = list[beg++];
      } else {
         temp[spot++] = list[mid++];
      }
   }
   while(beg < saveMid)
      temp[spot++] = list[beg++];
   while(mid < back)
      temp[spot++] = list[mid++];
   for(int i = 0; i < back-front; i++) {
      list[front+i] = temp[i];
   }
    System.out.println("pass " + passCount++ + " " + Arrays.toString(list) + "\n");
  }
 }

事实证明，使用while循环在列表中循环可以帮助您返回正确的值！
感谢您的建议。这样做可以消除堆栈溢出错误。它现在正在检查代码，但仍然没有正确排序。输入“9,5,3,2”会在第一遍中将其排序为“5,5,3,2”，在第二遍中排序为“5,5,2,2”，然后再输入第3页的“2，5，2，2”，这显然意味着我没有正确设置。再次感谢您的帮助，我将在我弄明白后再次发布。感谢您的建议。这样做可以消除堆栈溢出错误。它现在正在检查代码，但仍然没有正确排序。输入“9，5，3，2”将其排序为“5，5，3，2”第一遍是“5，5，2，2”，第二遍是“5，5，2，2”，第三遍是“2，5，2，2”，这显然意味着我没有正确设置。再次感谢您的帮助，我会在我弄明白后再次发布。感谢您的建议。这样做可以消除堆栈溢出错误。它现在正在检查代码，但仍然没有正确排序。输入“9,5,3,2”在第一遍中排序为“5,5,3,2”，在第二遍中排序为“5,5,2,2”，在第二遍中排序为“2,5,2,2”“在第三段中，这显然意味着我没有正确设置。再次感谢您的帮助，我将在找到它后再次发布。感谢您的建议。这样做可以消除堆栈溢出错误。它现在正在检查代码，但仍然没有正确排序。在第一段中，输入“9,5,3,2”将其排序为“5,5,3,2”，第二个是“5，5，2，2”，第三个是“2，5，2，2”，这显然意味着我的设置不正确。再次感谢你的帮助，一旦我弄明白了，我会再发一次。我不知道是什么迫使你在这么多年后回答我这个糟糕的问题，也不知道是什么让你这么做，因为你知道自己会很少受到关注