comments

// ============================================================================================ COMMENTS

//void countingSort(int *array, int size, int k = 10) // функция сортировки методом подсчета
//{
//    int counters[10] = {0}; // массив счетчиков
//
//    for (int i = 0; i < size; i++) // частотный анализ
//    {
//        counters[array[i]] += 1;
//    }
//
//    int i = 0; // переменная-индекс результирующего массива
//    for (int j = 0; j < k; j++)
//    {
//        while (counters[j] != 0) // вывод индекса counters столько раз, сколько записано в поле по этому индексу
//        {
//            array[i] = j; // запись в результ-й массив
//            counters[j]--; // уменьшение значения в массиве счетчиков
//            i++; // переход на следующий индекс результ-го массива
//        }
//    }
//}

//int pow(int number, int power)
//{
//    if (power == 0)
//    {
//        return 1;
//    }
//
//    int nSave = number;
//
//    int counter = 1;
//
//    while (counter != power)
//    {
//        number *= nSave;
//        counter++;
//    }
//
//    return number;
//}

//int getRadixDigit(int number, int radix)
//{
//    int count = 0;
//    int result = 0;
//
//    while (number != 0)
//    {
//        ++count;
//        result = number % 10;
//        number /= 10;
//
//        if (count == radix)
//        {
//            return result;
//        }
//    }
//
//    return result;
//}
//
//int insertToRadix(int number, int toInsert, int radix)
//{
//    int remainder = number % (pow(10, radix - 1));
//    int mainBody = number / (pow(10, radix));
//    int result = (mainBody * (pow(10, radix))) + (toInsert * (pow(10, (radix - 1)))) + remainder;
//
//    return result;
//}
//
//int* radixSort(int* array, int size, int d, int k = 10) // генератор рандомных чисел
//{
//    for (int i = 1; i <= d; i++) // цикл по разрядам чисел
//    {
//        int counters[10] = {0}; // массив счетчиков
//
//        for (int m = 0; m < size; m++) // частотный анализ
//        {
//            counters[getRadixDigit(array[m], i)] += 1;
//        }
//
//        int g = 0; // переменная-индекс результирующего массива
//        for (int j = 0; j < k; j++)
//        {
//            while (counters[j] != 0) // вывод индекса counters столько раз, сколько записано в поле по этому индексу
//            {
////                array[g] = array[g] / radixDelta + j; // запись в результ-й массив
//                array[g] = insertToRadix(array[g], j, i); // запись в результ-й массив j - toInsert
//                counters[j]--; // уменьшение значения в массиве счетчиков
//                g++; // переход на следующий индекс результ-го массива
//            }
//        }
//    }
//
//    return array;
//}

//void radixSort(int* array, int size, int d, int k = 10) // старый радикс
//{
//    List<float>* counters = new List<float>[k];
//
//    for (int i = 1; i <= d; i++)
//    {
//        for (int m = 0; m < size; m++) // частотный анализ
//        {
//            counters[getRadixDigit(array[m], i)] += array[m];
//        }
//
//        int g = 0; // переменная-индекс результирующего массива
//        for (int j = 0; j < k; j++)
//        {
//            while (!counters[j].isEmpty()) // вывод индекса counters столько раз, сколько записано в поле по этому индексу
//            {
//                array[g] = counters[j].popFront(); // запись в результ-й массив j - toInsert
//                g++; // переход на следующий индекс результ-го массива
//            }
//        }
//    }
//}

//void shellHibbardSort(int* array, int size)
//{
//    int swp = 0;
//    int comp = 0;
//    int k = 0;
//
//    double val = (int) log(size + 1) / log(2);
//    int increment = (int) pow(2, val) - 1;
// // increment =(int)9* pow(4,n)- 9* pow(2,n);
//
//    while (increment > 0)
//    {
//        for (int i = 0; i < increment; i++)
//        {
//            for (int j = 0; j < size; j += increment)
//            {
//                int temp = array[j];
//
//                for(k = j - increment; k >= 0 && temp < array[k]; k -= increment)
//                {
//                    comp++;
//                    swp++;
//                    array[k + increment] = array[k];
//                }
//
//                array[k + increment] = temp;
//                swp++;
//            }
//        }
//
//        comp++;
//        val--;
//
//        if (increment != 1)
//        {
//            increment = pow(2, val) - 1;
//        }
//        else
//        {
//            increment = 0;
//        }
//    }
//}

//void shellShellSort(int* array, int size)
//{
//    int k;
//    int swp = 0;
//    int comp = 0;
//    int increment = size / 2;
//
//    while (increment > 0)
//    {
//        for (int i = 0; i < increment; i++)
//        {
//            for (int j = 0; j < size; j += increment)
//            {
//                int temp = array[j];
//
//                for ( k = j - increment; k >= 0 && temp < array[k]; k -= increment)
//                {
//                    comp++;
//                    swp++;
//                    array[k + increment] = array[k];
//                }
//                array[k + increment] = temp;
//                swp++;
//            }
//        }
//
//        comp++;
//
//        if (increment / 2 != 0)
//        {
//            increment = increment / 2;
//        }
//        else if (increment == 1)
//        {
//            increment = 0;
//        }
//        else
//        {
//            increment = 1;
//        }
//    }
//}