Sort Algorithms

#include <iostream>

using namespace std;

void quickSort(int *numbers, int left, int right);
int lomutoPartition(int *numbers, int left, int right);
int hoarePartition(int *numbers, int left, int right);

void insertionSort(int *numbers, int length);

void swapNumbers(int *a, int *b);

int main() {
    int length;
    cin >> length;

    while (length != 0) {
        int *numbers = new int[length];
        for (int i = 0; i < length; i++)
            cin >> numbers[i];

        quickSort(numbers, 0, length - 1);
        for (int i = 0; i < length; i++)
            cout << numbers[i] << " " << flush;

        delete [] numbers;
        cout << endl;
        cin >> length;
    }
}

void quickSort(int *numbers, int left, int right) {
    if (left < right) {
        int pivot = hoarePartition(numbers, left, right);
        quickSort(numbers, left, pivot - 1);
        quickSort(numbers, pivot + 1, right);
    }
}

int lomutoPartition(int *numbers, int left, int right) {
    int pivot = numbers[left];
    int newPivotPos = left;

    for (int i = left; i <= right; i++) {
        if (numbers[i] < pivot) {
            newPivotPos++;
            swapNumbers(&(numbers[newPivotPos]), &(numbers[i]));
        }
    }

    swapNumbers(&(numbers[left]), &(numbers[newPivotPos]));
    return newPivotPos;
}

int hoarePartition(int *numbers, int left, int right) {
    int pivot = numbers[left];
    int leftCounter = left;
    int rightCounter = right + 1;

    do {
        do {
            leftCounter++;
        } while (leftCounter < right && numbers[leftCounter] < pivot);

        do {
            rightCounter--;
        } while (numbers[rightCounter] > pivot);

        swapNumbers(&(numbers[leftCounter]), &(numbers[rightCounter]));
    } while (leftCounter < rightCounter);

    swapNumbers(&(numbers[leftCounter]), &(numbers[rightCounter]));
    swapNumbers(&(numbers[left]), &(numbers[rightCounter]));

    return rightCounter;
}

void insertionSort(int *numbers, int length) {
    int lastSortedPos = 0;
    for (int i = 1; i < length; i++, lastSortedPos++) {
        int number = numbers[i];
        int counter = lastSortedPos;
        while (counter >= 0 && numbers[counter] > numbers[i])
            numbers[counter + 1] = numbers[counter--];

        nummbers[counter + 1] = number;
    }
}

void swapNumbers(int *a, int *b) {
    int aux = *a;
    *a = *b;
    *b = aux;
}