Java 合并排序到位

我正在研究一种合并排序方法，该方法在不分配额外内存的情况下对元素进行就地排序。然而，它现在还不能工作，我想知道是否有人可以帮助我，因为我知道这是一个相对简单的操作。先谢谢你

我的合并排序方法：

      RegisterClass[] runMergeSort()
  {
     RegisterClass[] mergeSorted = new RegisterClass[capacity];
     
     for (int counter = 0; counter < size; counter++)
        {
           mergeSorted[counter] = registerArray[counter];
        }
     
     runMergeSortHelper(mergeSorted, 0, size - 1);
     
     return mergeSorted;
  }

RegisterClass[]runMergeSort（）
{
RegisterClass[]合并排序=新的RegisterClass[容量]；
用于（int计数器=0；计数器<大小；计数器++）
{
合并排序[计数器]=寄存器阵列[计数器]；
}
运行合并排序器（合并排序，0，大小-1）；
返回并排序；
}

使用递归的My helper方法：

      private void runMergeSortHelper(RegisterClass[] workingArray,
                                  int lowIndex,
                                  int highIndex)
  {
     int midIndex = (lowIndex + highIndex) / 2;
     
     if (lowIndex < highIndex)
        {
           
           runMergeSortHelper(workingArray, lowIndex, midIndex);
           runMergeSortHelper(workingArray, midIndex+1, highIndex);
                          
           runMerge(workingArray, lowIndex, midIndex, highIndex);
        }
              

  }

private void runMergeSortHelper（注册表类[]工作阵列，
int低指数，
整数（高索引）
{
int midIndex=（低指数+高指数）/2；
if（低指数<高指数）
{
runMergeSortHelper（工作阵列、低索引、midIndex）；
runMergeSortHelper（工作阵列，midIndex+1，高索引）；
runMerge（工作阵列、低索引、中索引、高索引）；
}
}

最后是我的合并方法，它应该把所有的事情都整理好，但是，它只做了一部分

      private void runMerge(RegisterClass[] workingArray,
                        int lowIndex,
                        int midIndex,
                        int highIndex)
  {
     int counterJay = midIndex;
     int counterAye = lowIndex;
     int counterKay = lowIndex - 1;
              
     while (counterAye < midIndex && counterJay <= highIndex)
        {
           counterKay++;
           
           if (workingArray[counterAye].compareTo(workingArray[counterJay]) <= -1)
              {
                 counterAye++;
              }
           
           else
              {
                 swapValues(workingArray, counterAye, counterJay);
                 counterJay++;
                 counterAye++;
              }
           
        }
     
     while (counterAye < midIndex)
        {
           counterKay++;
           swapValues(workingArray, counterAye, counterKay);
           counterAye++;
        }
     
     while (counterJay <= highIndex)
        {
           counterKay++;
           swapValues(workingArray, counterJay, counterKay);
           counterJay++;
        }
  }

private void runMerge（RegisterClass[]工作阵列，
int低指数，
int midIndex，
整数（高索引）
{
int counterJay=midIndex；
int counterAye=低指数；
int counterKay=低指数-1；
while（counterAye
当发现右侧的元素小于左侧的元素时，需要右旋转阵列的该部分以将右侧元素放置到位


在不使用更复杂的实现的情况下，可以通过扫描右侧的k=前导元素数小于左侧的当前元素数，然后按k个元素向右旋转来进行小优化。对于随机数据，这不会有多大帮助，但对于反向排序的数据，这会有很大帮助。
为什么不使用using heapsort？这是一个课堂作业，必须使用这种类型：p这很有帮助。我找到了其他资源，我相信我可以用它来完成。谢谢。