#include <stdio.h>
int data[100];
int temparray[100];
void qsort( int*, int n );
void insertsort( int*, int n );
void quicksort( int*, int a, int b );
void quickswap( int* a, int* b );
void heapsort( int*, int n );
void buildmaxheap( int*, int a, int n );
void mergesort( int*, int n );
void merge( int* a, int na, int* b, int nb, int* temp );
int main()
{
    char c;
    int n = 0;
    printf( "which sort do you want: -q <quick_sort> -i <insert sort> -h <heap_sort> -m <merge_sort>\n" );
    c = getchar();
    printf( "Enter your data size\n" );
    scanf( "%d", &n );
    for( int i = 0;i < n; ++i )
    {
        scanf( "%d", data + i );
    }
    switch( c )
    {
        case 'q':
            qsort( data, n );
            break;
        case 'i':
            insertsort( data, n );
            break;
        case 'h':
            heapsort( data, n );
            break;
        case 'm':
            mergesort( data, n );
            break;
        default:
            printf( "unknown sort type\n" );
            break;
    }
    for( int i = 0;i < n; ++i )
        printf( "%d ", data[i] );
    printf( "\n" );

    return 0;
}

void qsort( int* data, int n )
{
    if( n <= 1 )
        return;
    quicksort( data, 0, n );
}

void quicksort( int* data, int a, int b )
{
    if( a + 1 >= b )
        return;
    int key = data[b-1];
    int i = a, j = a - 1;
    for( ; i < b - 1; ++i )
    {
        if( data[i] >= key )
            continue;
        else
        {
            ++j;
            quickswap( data + i, data + j );
        }
    }
    quickswap( data + j + 1, data + b - 1 );
    quicksort( data, a, j );
    quicksort( data, j + 1, b );
}

void quickswap( int* a, int* b )
{
    if( a == b )
        return;
    int temp = *a;
    *a = *b;
    *b = temp;
}

void insertsort( int* data, int n )
{
    if( n <= 1 )
        return;
    for( int i = 1; i < n; ++i )
    {
        int temp = data[i], j = i - 1;
        for( ;j >= 0; --j )
        {
            if( data[j] > temp )
                data[j+1] = data[j];
            else
                break;
        }
        data[j+1] = temp;
    }
    return;
}

void heapsort( int* data, int n )
{
    if( n <= 1 )
        return;
    int b = ( n - 1 ) / 2;
    for( int i = b;i >= 0; --i )
        buildmaxheap( data, i, n );
    for( int i = 0;i < n - 1; ++i )
    {
        quickswap( data, data + n - i - 1 );
        buildmaxheap( data, 0, n - i - 1 );
    }
}

void buildmaxheap( int* data, int a, int n )
{
    int index = a;
    if( 2 * a + 1 < n && data[2 * a + 1] > data[index] )
        index = 2 * a + 1;
    if( 2 * a + 2 < n && data[2 * a + 2] > data[index] )
        index = 2 * a + 2;
    if( a != index )
    {
        quickswap( data + a, data + index );
        buildmaxheap( data, index, n );
    }
}

void mergesort( int* data, int n )
{
    if( n <= 1 )
        return;
    int trunc = n / 2;
    mergesort( data, trunc );
    mergesort( data + trunc, n - trunc );
    merge( data, trunc, data + trunc, n - trunc, temparray );
    for( int i = 0;i < n; ++i )
        *( data + i ) = temparray[i];
}

void merge( int* a, int na, int* b, int nb, int* temparray )
{
    int i = 0, j = 0, k = 0;
    while( i < na && j < nb )
    {
        if( *( a + i ) > *( b + j ) )
            *( temparray + k++ ) = *( b + j++ );
        else
            *( temparray + k++ ) = *( a + i++ );
    }
    if( i == na )
        while( j < nb )
            *( temparray + k++ ) = *( b + j++ );
    else
        while( i < na )
            *( temparray + k++ ) = *( a + i++ );
}