使用插入排序快速排序

Question

我已经在这个代码上工作了好几个小时。目标是在指针数组上编写一个优化的QuickSort（带插入排序）（指向可以比较的对象）。插入排序应该与数组大小＆lt; 4。

到目前为止，当我传入一个数组时，我有插入排序工作＆lt; 4。

快速排序应该使用中间索引作为枢轴，并移动所有内容＆lt;枢轴左侧的枢轴，以及一切＆gt;枢轴右侧的枢轴。

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

如果有任何不清楚的地方，请告诉我。谢谢你的帮助！

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;
        }
    }
}