C++ 带插入排序的快速排序

我已经花了好几个小时研究这个代码了。目标是在指针数组（指向可以比较的对象）上编写优化的快速排序（带有插入排序）。插入排序应该在数组大小小于4的情况下使用

到目前为止，当我传入一个小于4的数组时，插入排序工作正常

快速排序应该使用中间索引作为轴心，并将所有内容<轴心移动到轴心的左侧，将所有内容>轴心移动到轴心的右侧

我甚至不确定我的整体快速排序方法是否正确。这是我第一次尝试写一个快速排序。我真的可以朝正确的方向轻推一下。注释掉的代码是我已经尝试过的

如果有什么不清楚的地方，请告诉我。谢谢你的帮助

void quickSort(Comparable ** array, int fromIndex, int toIndex)
{
    while (fromIndex < toIndex)
    {
        if ((toIndex - fromIndex +1 ) < 4)
        {
            insertionSort(array, fromIndex, toIndex);
            break;
        }
        else
        {
            int pivotIndex = partition(array, fromIndex, toIndex);
            quickSort(array, fromIndex, pivotIndex - 1);
            quickSort(array, pivotIndex + 1, toIndex);
        }
    }
}
int partition(Comparable ** array, int fromIndex, int toIndex)
{
    //Comparable *front = array[fromIndex+1];
    int midIndex = (toIndex + fromIndex) / 2;
    //int frontIndex = fromIndex;
    //Comparable *back = array[toIndex - 1];
    //int backIndex = toIndex - 1;
    //Comparable *compare = front;
    //int compareIndex = frontIndex;

    SortFirstMiddleLast(array, fromIndex, midIndex, toIndex);
    swap(array, midIndex, toIndex - 1);
    int pivotIndex = toIndex - 1;
    Comparable * pivot = array[pivotIndex];
    int indexLeft = fromIndex + 1;
    int indexRight = toIndex - 2;

    bool sortFinished = false;
        while (*array[indexLeft] < *pivot)
        {
            indexLeft++;
        }
        while (*array[indexRight] > *pivot)
        {
            indexRight--;
        }
        if ((*array[indexLeft] >= *pivot) && (*array[indexRight] <= *pivot))
        {
            if (indexLeft < indexRight)
            {
                swap(array, indexLeft, indexRight);
                indexLeft++;
                indexRight--;
                sortFinished = true;
            }
        }
            if (sortFinished == true)
            {
                swap(array, pivotIndex, indexLeft);
                pivotIndex = indexLeft;
                return pivotIndex;
            }

//  ++frontIndex; // advance to next element
//  while (*array[frontIndex] < *array[backIndex])
//  {
//      // search forward for out of order element
//      while ((*array[frontIndex] < *array[backIndex]) && (*array[fromIndex] > *array[frontIndex]))
//          ++frontIndex;
//      //search backward for out of order element
//      while ((*array[frontIndex] < *array[backIndex]) && (*array[compareIndex] <= *array[backIndex]))
//          --backIndex;
//      swap(array, frontIndex, backIndex);
//  }
//  //insert mid position comparison element
//  if (*array[compareIndex] >= *array[frontIndex])
//  {
//      swap(array, fromIndex, frontIndex);
//      returnValue = frontIndex;
//  }
//  else
//  {
//      swap(array,fromIndex, (frontIndex - 1));
//      returnValue = (frontIndex - 1);
//  }
//  return returnValue;
}
void swap(Comparable ** array, int swapIndex1, int swapIndex2)
{
    Comparable * temp = array[swapIndex1];
    array[swapIndex1] = array[swapIndex2];
    array[swapIndex2] = temp;
}

void SortFirstMiddleLast(Comparable ** array, int fromIndex, int midIndex, int toIndex)
{ 
    // first must be less than mid, must be less than last
    if (*array[fromIndex] > *array[midIndex])
    {
        swap(array, fromIndex, midIndex);
    }
    if (*array[fromIndex] > *array[toIndex - 1])
    {
        swap(array, fromIndex, toIndex - 1);
    }
    if (*array[midIndex] > *array[toIndex - 1])
    {
        swap(array, midIndex, toIndex - 1);
    }
}
void insertionSort(Comparable ** array, int fromIndex, int toIndex)
{
    for (unsigned i = fromIndex + 1; i < toIndex; i++)
    {
        for (unsigned j = i; j > 0; j--)
        {
            if (*array[j] < *array[j - 1])
            {
                swap(array, j, j-1);
            }
            else
                break;
        }
    }
}

void快速排序（可比较**数组、int-fromIndex、int-toIndex）
{
while（从索引<到索引）
{
如果（（toIndex-fromIndex+1）<4）
{
插入排序（数组、从索引到索引）；
打破
}
其他的
{
int pivotIndex=分区（数组、fromIndex、toIndex）；
快速排序（数组、fromIndex、pivotIndex-1）；
快速排序（数组，数据透视索引+1，toIndex）；
}
}
}
int分区（可比较**数组、int-fromIndex、int-toIndex）
{
//可比较*front=数组[fromIndex+1]；
int midIndex=（toIndex+fromIndex）/2；
//int frontIndex=fromIndex；
//可比*back=数组[toIndex-1]；
//int backIndex=toIndex-1；
//可比*比较=正面；
//int compareIndex=frontIndex；
SortFirstMiddleLast（数组、fromIndex、midIndex、toIndex）；
交换（数组、midIndex、toIndex-1）；
int pivotIndex=toIndex-1；
可比较*pivot=数组[数据透视索引]；
int indexLeft=fromIndex+1；
int indexRight=toIndex-2；
bool-sortFinished=false；
while（*数组[indexLeft]<*枢轴）
{
indexLeft++；
}
而（*数组[indexRight]>*pivot）
{
指数右--；
}
if（（*array[indexLeft]>=*pivot）和（*array[indexRight]*array[frontIndex]））
//++frontIndex；
////向后搜索无序元素
//而（（*数组[frontIndex]<*数组[backIndex]）&&（*数组[compareIndex]=*数组[frontIndex]）
//  {
//交换（数组、fromIndex、frontIndex）；
//returnValue=frontIndex；
//  }
//否则
//  {
//交换（数组，fromIndex，（frontIndex-1））；
//returnValue=（frontIndex-1）；
//  }
//返回值；
}
无效交换（可比**数组、整数交换索引1、整数交换索引2）
{
可比*温度=阵列[swapIndex1]；
数组[swapIndex1]=数组[swapIndex2]；
数组[swapIndex2]=温度；
}
void SortFirstMiddleLast（可比较**数组、int-fromIndex、int-midIndex、int-toIndex）
{ 
//第一个必须小于中间，必须小于最后一个
if（*数组[fromIndex]>*数组[midIndex]）
{
交换（数组、fromIndex、midIndex）；
}
if（*数组[fromIndex]>*数组[toIndex-1]）
{
交换（数组、从索引到索引-1）；
}
if（*数组[midIndex]>*数组[toIndex-1]）
{
交换（数组、midIndex、toIndex-1）；
}
}
void insertionSort（可比**数组、int-fromIndex、int-to-Index）
{
for（无符号i=fromIndex+1；i0；j--）
{
if（*数组[j]<*数组[j-1]）
{
交换（阵列，j，j-1）；
}
其他的
打破
}
}
}

Stack Overflow不是一项免费的调试服务，我们希望您能展示使用调试器或其他更简单的方法（如调试打印语句）调试代码的尝试。这不会是您代码中出现错误的唯一一次，学习调试程序比让别人为您查找错误更有帮助这可能会有帮助：有一条通过

分区的路径不返回值。如果您选择该路径，则程序未定义。