/*************************************************/
/* PERFORM SORTING USING BUBBLE METHOD */
/*************************************************/

// Bubble сортировка

void sortbubble(long num, float *array)
// num - число эллементов
// array - указатель на первый эллемент массива
{
    // Sorting using well-known bubble method
    short sorted = 1; //flag, 0 - array not sorted, 1 - sorted
    short changed = 0; //flag, at least one pair was switched
    float temp;

    do
    {
        changed = 0;
        for (long i = 0; i < num - 1; i++)
        {
            if (array[i] > array[i+1])
            {
                temp = array[i];
                array[i] = array[i+1];
                array[i+1] = temp;
                changed = 1;
            }
        }
        sorted = !changed;
    } while (!sorted);

}

/*************************************************/
/* PERFORM SORTING USING MINIMA METHOD */
/*************************************************/

//also known as most "natural" sorting method

// Minima сортировка

void sortminima (long num, float *array)
// num - число эллементов
// array - указатель на первый эллемент массива
{
    long k,s,t;
    k = 0;
    float temp;

    while (k < num)
    {
        s = k;
        t = s;
        while (t < num-1)
        {
            t++;
            if (array[t] < array[s]) s = t;
        }
        temp = array[s];
        array[s] = array[k];
        array[k] = temp;
        k++;
    }
}

/*************************************************/
/* PERFORM SORTING USING SIMPLE INCLUSION METHOD */
/*************************************************/

//taken from alglib block scheme.

// Simple Inclusion сортировка

void sortsimpinc(long num, float *array)
// num - число эллементов
// array - указатель на первый эллемент массива
{
    long i,j,k;
    float temp;

    i = 1;

    do
    {
        j = 0;
        do
        {
            if (array[i] <= array [j])
            {
                k = i;
                temp = array[i];
                do
                {
                    array[k] = array[k-1];
                    k--;
                } while (k > j);

                array[j] = temp;
                j = i;
            }
            else j++;
        } while (j < i);
        i++;
    } while (i < num);
}

/*************************************************/
/* PERFORM SORTING USING BINARY INCLUSION METHOD */
/*************************************************/

//taken from alglib block scheme

// Binary Inclusion сортировка

void sortbininc(long num, float *array)
// num - число эллементов
// array - указатель на первый эллемент массива
{
    long i, b, e, c, k;
    float temp;

    i = 1;
    do
    {
        b = 0;
        e = i - 1;
        c= (b + e)/2;

        while (b != c)
        {
            if (array[c] > array[i]) e=c; else b=c;
            c = (b + e)/2;
        }

        if (array[b] < array[i])
            if (array[i] > array[e]) b = e + 1; else b = e;
        k=i;
        temp = array[i];

        while (k > b)
        {
            array[k] = array[k-1];
            k--;
        }

        array[b] = temp;
        i++;
    } while (i < num);
}

/*************************************************/
/* PERFORM SORTING USING SHELL METHOD */
/*************************************************/

//taken from alglib block scheme

// Shell сортировка

void sortshell (long num, float *array)
// num - число эллементов
// array - указатель на первый эллемент массива
{
    long i,j,g;
    short c; //flag
    float temp;

    g = num/2;
    do
    {
        i = g;
        do
        {
            j = i - g;
            c = 1;
            do
            {
                if (array[j] <= array[j+g]) c = 0;
                else 
                {
                    temp = array[j];
                    array[j] = array[j+g];
                    array[j+g] = temp;
                }
                j--;
            } while(j >= 0 && c);
            i++;
        } while(i < num);
        g = g/2;
    } while(g > 0);
}