实现混合插入和快速排序C ++

Question

I'm trying to implement a hybrid insertion and quick sort. The task is to use quicksort for large vectors and whenever the vectors become smaller than some specified value (crossover point) the algorithm should switch to insertion sort. I have this code so far but it does not sort vectors and I don't know why. Any help would be appreciated. Thanks!

#include <iostream>
#include "console.h"
#include "vector.h"  // for Vector
#include <cmath>
using namespace std;


/* Partition for quicksort algorithm */
int partition(Vector<int> &vec, int start, int end){
    int lh = start +1;
    int rh = end;
    int pivotVal = vec[start];

    while (true){
        while (lh<rh && vec[lh]<pivotVal) lh++;
        while (rh>lh && vec[rh]>=pivotVal) rh--;
        if (lh==rh) break;
        swap(vec[lh], vec[rh]);
    }

    if (pivotVal<vec[lh]) return start;
    swap(vec[start], vec[lh]);
    return lh;
}


/* Regular quicksort */
void quickSort(Vector<int> &vec, int start, int end){
    if(start<end){
        int pivotIndex = partition(vec, start, end);
        quickSort(vec, start, pivotIndex-1);
        quickSort(vec, pivotIndex+1, end);
    }
}


/* Insertion sort algorithm */
void insertionSort(Vector<int> &vec, int start, int end){
    int size = vec.size();
    for (int i=start; i<end; i++){
        int j=i;
        while (j>start && vec[j-1]>vec[j]){
            swap(vec[j-1], vec[j]);
            j--;
        }
    }
}



/* Hybrid quicksort & insertion sort, as soon as the part of the vector to 
   sort becomes less than the crossover value, the algorithm switches to 
   insertion sort, otherwise it 
   uses quicksort */
void hybridSort(Vector<int> &vec, int start, int end, int crossover){
    if(start < end){
        if (end-start <= crossover){
            insertionSort(vec, start, end);
        } else {
            int pivotIndex = partition(vec, start, end);
            hybridSort(vec, start, pivotIndex-1, crossover);
            hybridSort(vec, pivotIndex+1, end, crossover);
        }
    }
}



int main() {

    Vector<int> vec {9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 14, 39, 30, 83, 92, 41};
    int end = vec.size()-1;
    hybridSort(vec, 0, end, 4);
    cout << vec.toString() <<endl;

    return 0;

}

Answer 1

I rewrote partition :

int partition(Vector<int>& vec, int start, int end) {
    int pivot = start;
    for(int i = start + 1; i <= end; ++i) {
        if(vec[i] < vec[pivot]) {
            swap(vec[pivot + 1], vec[i]);
            swap(vec[pivot], vec[pivot + 1]);
            ++pivot;
        }
    }
    return pivot;
}

There's also a bug in insertionSort . It should be i <= end instead of i < end . Here's the fixed version:

void insertionSort(Vector<int>& vec, int start, int end) {
    for(int i = start; i <= end; i++) {
        int j = i;
        while(j > start && vec[j-1] > vec[j]) {
            swap(vec[j-1], vec[j]);
            j--;
        }
    }
}