Вы находитесь на странице: 1из 20

Министерство науки и высшего образования Российской Федерации

Федеральное государственное автономное образовательное


учреждение высшего образования
Национальный исследовательский Нижегородский государственный
университет им. Н.И. Лобачевского

Институт информационных технологий, математики и механики

Отчет по лабораторной работе

«Моделирование работы сортировщика файлов ОС»

Выполнил:
студент группы 381803-1
Герасимов М. А.

Проверил:
доцент кафедры МОСТ, к.т.н.,
Сысоев А.В.

Нижний Новгород
2018
Содержание
Введение.........................................................................................................................................3
1. Постановка задачи..............................................................................................................4
2. Руководство пользователя.................................................................................................5
3. Руководство программиста................................................................................................7
3.1. Описание структуры программы......................................................................................7
3.2. Описание алгоритмов.........................................................................................................8
4. Результаты экспериментов..............................................................................................13
Заключение...................................................................................................................................14
Литература....................................................................................................................................15
Приложение..................................................................................................................................16

2
Введение
Файловые менеджеры очень популярны в настоящее время. Они
предоставляют пользователю возможность удобной работы с файлами в любой
операционной системе. Одной из наиболее важных функций файлового
менеджера является сортировка файлов по размеру. Благодаря ей пользователь
быстро может определить, какие файлы больше всего нагружают диск и от каких
файлов в первую очередь стоит избавиться при его чистке.
1. Постановка задачи
Разработать прототип файлового менеджера с функцией показа файлов в
заданном каталоге, упорядоченных по возрастанию/убыванию размера.

Входные данные:
 Путь до директории, в которой необходимо отсортировать содержимое.
 Метод сортировки.

Выходные данные:
 Отсортированный список имен файлов с указанием размера.
 Время сортировки.

Программа должна предоставлять пользователю возможность сменить метод


сортировки и повторно формировать выходные данные.

Программа должна реализовывать диалог с пользователем посредством


интерфейса, который включает:
 возможность ввода пути до заданного каталога;
 возможность выбора метода сортировки;
 возможность просмотра отсортированного списка файлов с указанием
размера.

Cписок методов сортировки:


 пузырьком,
 выбором,
 вставками,
 слиянием,
 Хоара,
 Шелла,
 расческой.
2. Руководство пользователя
При старте программы открывается консоль, где предлагается ввести путь до
директории, файлы которой вы хотите просмотреть и отсортировать. (рис. 1).

Рис. 1. «Введите путь до директории».

После ввода пути в консоли появится список файлов из данной директории


с указанием даты создания файла и его размера. (рис. 2). Далее вам будет
предложен список сортировок, с помощью которых вы можете отсортировать
файлы по размеру. На данный момент программа поддерживает сортировки:
1. пузырьком (Bubble Sort),
2. выбором (Selection Sort),
3. бинарными вставками (Binary Insertion Sort),
4. слиянием (Merge Sort),
5. быстрая Хоара (Quick Sort),
6. Шелла (Shell Sort),
7. расческой (Comb Sort).

Рис. 2. «Список файлов и выбор способа сортировки».

После выбора метода сортировки программа предложит выбрать, каким


образом сортировать файлы: по возрастанию или по убыванию (рис. 3).
Рис. 3. «Выбор порядка сортировки».

Далее программа выведет в консоль отсортированный список файлов, а


также время, затраченное на сортировку в миллисекундах. (рис. 4) После этого
Вам будет предложено либо продолжить работу и отсортировать файлы еще раз,
либо выйти из программы.

Рис. 4. «Вывод отсортированного списка файлов».


3. Руководство программиста
3.1. Описание структуры программы
Исходный код программы написан на языке программирования C и
расположен в файле Source.cpp.

Основные блоки программы:


 Структура ELEMENT. Содержит символьный массив name из 260
элементов, хранящий имя файла; символьный массив date из 30
элементов, хранящий дату создания файла; переменную типа long,
хранящую размер файла.
 Функция KapitanovBubbleSort. Данная функция реализует метод
сортировки пузырьком. Входные параметры: указатель на массив типа
ELEMENT, нижняя и верхняя границы массива, режим сортировки
(возр./убыв.).
 Функция SelectionSort. Данная функция реализует метод сортировки
выбором. Входные параметры: указатель на массив типа ELEMENT,
нижняя и верхняя границы массива, режим сортировки (возр./убыв.).
 Функция BinarySearch. Реализует метод бинарного поиска. Входные
параметры: указатель на массив типа ELEMENT, нижняя и верхняя
границы упорядоченной части массива, режим сортировки
(возр./убыв.), ключ поиска (элемент, по которому ведется поиск).
 Функция InsertSort. Данная функция реализует метод сортировки
бинарными вставками. Входные параметры: указатель на массив типа
ELEMENT, нижняя и верхняя границы массива, режим сортировки
(возр./убыв.). Эта функция использует вспомогательную функцию
BinarySearch.
 Функция Merge. Данная функция «сливает» две упорядоченных части
массива в одну. Входные параметры: указатель на массив типа
ELEMENT, нижняя и верхняя граница первой упорядоченной части
массива, верхняя граница второй упорядоченной части массива,
режим сортировки (возр./убыв.).
 Функция MergeSort. Данная функция реализует метод сортировки
слиянием. Входные параметры: указатель на массив типа ELEMENT,
нижняя и верхняя границы массива, режим сортировки (возр./убыв.).
Эта функция использует вспомогательную функцию Merge.
 Функция QuickSort. Данная функция реализует метод быстрой
сортировки Хоара. Входные параметры: указатель на массив типа
ELEMENT, нижняя и верхняя границы массива, режим сортировки
(возр./убыв.).
 Функция IncCount. Данная функция считает последовательность
Седжвика для сортировки Шелла. Входные параметры: указатель на
целочисленный массив, в который будет записана
последовательность, длина сортируемого массива. Функция
возвращает номер последнего элемента последовательности.
 Функция ShellSort. Данная функция реализует метод сортировки
Шелла. Входные параметры: указатель на массив типа ELEMENT,
нижняя и верхняя границы массива, режим сортировки (возр./убыв.).
Эта функция использует вспомогательную функцию IncCount.
 Функция CombSort. Данная функция реализует метод сортировки
расческой. Входные параметры: указатель на массив типа ELEMENT,
нижняя и верхняя границы массива, режим сортировки (возр./убыв.).
 Также программа использует массив Sort, который является массивом
указателей на функции. Каждый элемент массива соответствует одной
из функций сортировки.

3.2. Описание алгоритмов


1) Сортировка пузырьком

Алгоритм состоит из повторяющихся проходов по массиву. За каждый


проход соседние элементы последовательно сравниваются попарно и, если
порядок в паре неверный, меняются местами. Проходы по массиву повторяются
N-1 раз или до тех пор, пока на очередном проходе не окажется, что массив
отсортирован. При каждом проходе алгоритма по внутреннему циклу, очередной
наибольший элемент массива ставится на своё место в конце массива рядом с
предыдущим «наибольшим элементом», а наименьший элемент перемещается на
одну позицию к началу массива.

Реализация на C:
bool flag = true;

for (int i = down; flag; i++)


{
flag = false;
for (int j = down; j < up - i; j++)
if ((mas[j] < mas[j + 1]) && (mode == -1) || (mas[j] > mas[j + 1]) && (mode == 1))
{
int tmp = mas[j];
mas[j] = mas[j + 1];
mas[j + 1] = tmp;
flag = true;
}
}

2) Сортировка выбором

Алгоритм состоит из повторяющегося поиска минимального (или


максимального) элемента в неотсортированной части массива. В конце каждого
этапа поиска проходит обмен найденного элемента с элементом на первой
позиции неотсортированной части. Затем элемент на этой позиции исключается
из неотсортированной части.

Реализация на C:

for (int i = down; i < up; i++)


{
int maxim = mas[i];
int num = i;
for (int j = i + 1; j < up + 1; j++)
if ((mas[j] > maxim) && (mode == -1) || (mas[j] < maxim) && (mode == 1))
{
maxim = mas[j];
num = j;
}
int tmp = mas[num];
mas[num] = mas[i];
mas[i] = tmp;
}

3) Сортировка бинарными вставками

Суть алгоритма в том, что элементы массива последовательно


просматриваются по одному, и каждый новый элемент размещается в подходящее
место среди ранее упорядоченных. В начальный момент отсортированная часть
пуста. На каждом шаге алгоритма выбирается один из элементов и помещается на
нужную позицию в уже отсортированной последовательности до тех пор, пока
массив не закончится.

Для поиска нужной позиции используется алгоритм бинарного поиска. В


отсортированной части массива выбирается элемент посередине. Если входной
элемент больше выбранного, то те же действия повторяются для правой половины
отсортированной части массива, если же нет – для левой. Цикл продолжается до
тех пор, пока выбранный элемент не совпадет с входным или же длина очередной
половины не окажется равной единице.

Реализация на C:

Бинарный поиск:
while (down < up)
{
int mid = int(up + (down - up) / 2.0);
if ((mas[mid] < insert) && (mode == -1) || (mas[mid] > insert) && (mode == 1))
up = mid;
else if((mas[mid] > insert) && (mode == -1) || (mas[mid] < insert) && (mode == 1))
down = mid + 1;
else
{
up = mid;
down = mid;
}
}
return up;

Сортировка вставками:
for (int i = down + 1; i < up + 1; i++)
{
if ((mas[i] > mas[i - 1]) && (mode == -1) || (mas[i] < mas[i - 1]) && (mode == 1))
{
int num;
if ((mas[i] < mas[0]) && (mode == -1) || (mas[i] > mas[0]) && (mode == 1))
num = BinarySearch(mas, down, i-1, mode, mas[i]);
else
num = down;
int tmp = mas[i];
for (int j = i; j > num; j--)
mas[j] = mas[j - 1];
mas[num] = tmp;
}
}

4) Сортировка слиянием

Алгоритм основан на принципе «разделяй и властвуй», т.е. задача


разбивается на несколько подзадач меньшего размера, которые решаются с
помощью рекурсивного вызова. Затем их решения комбинируются и получается
решение исходной задачи. В данном случае массив разбивается на две равные
части, затем каждая из них сортируется тем же способом, а потом обе
отсортированные части соединяются в одну отсортированную.

Реализация на С:
void Merge(int * mas, int down, int mid, int up, int mode)
{
int * tmp = new int [up - down + 1];
int i = down, j = mid + 1;

while ((i < mid + 1) && (j < up + 1))


if ((mas[i] < mas[j]) && (mode == -1) || (mas[i] > mas[j]) && (mode == 1))
{
tmp[i + j - down - mid - 1] = mas[j];
j++;
}
else
{
tmp[i + j - down - mid - 1] = mas[i];
i++;
}
if (i == mid + 1)
for (; j < up + 1; j++)
tmp[i + j - down - mid - 1] = mas[j];
else
for (; i < mid + 1; i++)
tmp[i + j - down - mid - 1] = mas[i];
for (i = down; i < up + 1; i++)
mas[i] = tmp[i - down];
}

void MergeSort(int * mas, int down, int up, int mode)


{
if (down < up)
{
int mid = int(up + (down - up) / 2.0);
MergeSort(mas, down, mid, mode);
MergeSort(mas, mid + 1, up, mode);
Merge(mas, down, mid, up, mode);
}
}

5) Быстрая сортировка Хоара

Этот алгоритм также основан на принципе «разделяй и властвуй». Сначала


выбирается опорный элемент массива (часто роль опорного играет серединный),
затем элементы меньше опорного помещаются слева от него (или справа, если
массив сортируется по убыванию), а больше – справа (или слева). Затем то же
самое повторяется для частей массива справа и слева от опорного.

Реализация на C:
void QuickSort(int * mas, int down, int up, int mode)
{
int i = down, j = up, fixik = mas[int(up + (down - up) / 2.0)];

while (i <= j)
{
while ((mas[j] < fixik) && (mode == -1) || (mas[j] > fixik) && (mode == 1))
j--;
while ((mas[i] > fixik) && (mode == -1) || (mas[i] < fixik) && (mode == 1))
i++;
if (i <= j)
{
int tmp = mas[i];
mas[i] = mas[j];
mas[j] = tmp;
i++;
j--;
}
}
if (down < j)
QuickSort(mas, down, j, mode);
if (up > i)
QuickSort(mas, i, up, mode);
}

6) Сортировка Шелла

Суть алгоритма в том, что сортируются элементы массива, стоящие друг от


друга на расстоянии d, при этом d с каждым новым проходом по массиву
уменьшается. После прохода при d равном 1, алгоритм завершается. Подбор d
можно осуществлять разными способами, существует много различных формул.
Одной из самых оптимальных считается предложенная Седжвиком
i i+1
последовательность: d i=9∙ 2i−9∙ 2 2 + 1, если i четное и d i=8∙ 2i−6 ∙ 2 2 +1, если i
нечетное.

Реализация на C:

Считаем формулу Седжвика:


int IncCount(int * inc, int len)
{
int i = -1, shift, shift_chet, shift_nechet;

shift = shift_chet = shift_nechet = 1;


do
{
i++;
if (i % 2 == 0)
{
inc[i] = 9 * shift - 9 * shift_chet + 1;
shift_chet *= 2;
shift_nechet *= 2;
}
else
inc[i] = 8 * shift - 6 * shift_nechet + 1;
shift *= 2;
} while (inc[i] * 3 < len);
if (i == 0)
return 0;
else
return i - 1;
}

Сортировка Шелла:
void ShellSort (int * mas, int down, int up, int mode)
{
int * inc = new int[int(log2(up + 1))];
int index = IncCount(inc, up + 1);

for (int i = index; i >= 0; i--)


for (int j = inc[i]; j < up + 1; j++)
{
int k;
int tmp = mas[j];
for (k = j - inc[i]; (k >= down) && ((mas[k] < tmp) && (mode == -1) ||
(mas[k] > tmp) && (mode == 1)); k -= inc[i])
mas[k + inc[i]] = mas[k];
mas[k + inc[i]] = tmp;
}
}

7) Сортировка расческой

Алгоритм улучшает стандартный метод сортировки «пузырьком». Идея в


том, чтобы первоначально брать достаточно большое расстояние между
сравниваемыми элементами и по мере упорядочивания массива сужать это
расстояние вплоть до минимального. Таким образом, мы как бы причёсываем
массив, постепенно разглаживая на всё более аккуратные пряди. Первоначальный
разрыв между сравниваемыми элементами лучше брать с учётом специальной
величины, называемой фактором уменьшения, оптимальное значение которой
равно примерно 1,247. Сначала расстояние между элементами равно размеру
массива, разделённого на фактор уменьшения (результат округляется до
ближайшего целого). Затем, пройдя массив с этим шагом, необходимо поделить
шаг на фактор уменьшения и пройти по списку вновь. Так продолжается до тех
пор, пока разность индексов не достигнет единицы. В этом случае массив
досортировывается обычным пузырьком.

Реализация на C:
const float factor = 1.247;

for (int i = int((up + 1) / factor); i >= 1; i = int(i / factor))


{
for (int j = down; j < up + 1 - i; j++)
if ((mas[j] < mas[j + i]) && (mode == -1) || (mas[j] > mas[j + i]) && (mode ==
1))
{
int tmp = mas[j];
mas[j] = mas[j + i];
mas[j + i] = tmp;
}
}

*досортировка обычным пузырьком*

4. Результаты экспериментов
Для проведения эксперимента выбирались массивы с количеством элементов
от 20 до миллиона. В ходе эксперимента было установлено, что:

 сортировка Хоара, Шелла и расческой показали наиболее хорошее время,


 сортировка пузырьком оказалась самой медленной.
Пузырек Выбор Вставки Слияние Хоара Шелла Расческой
1000 эл. 4 мс 1 мс 1 мс <1 мс <1 мс <1 мс <1 мс
10000 эл. 375 мс 125 мс 53 мс 5 мс 1 мс 2 мс 2 мс
50000 эл. 8.2 с 2.9 с 1.3 с 24 мс 6 мс 12 мс 13 мс
100000 эл. 32.5 с 11.5 с 5.1 с 50 мс 13 мс 24 мс 26 мс
Заключение
Разработана программа, представляющая собой прототип файлового
менеджера с функцией показа файлов в заданном каталоге, упорядоченных по
возрастанию/убыванию размера.

Программа предоставляет пользователю возможность сменить метод


сортировки и повторно формировать выходные данные.

Программа реализует диалог с пользователем посредством интерфейса,


который включает:
 возможность ввода пути до заданного каталога;
 возможность выбора метода сортировки;
 возможность просмотра отсортированного списка файлов с указанием
размера.

Cписок реализованных методов сортировки:


 пузырьком,
 выбором,
 вставками,
 слиянием,
 Хоара,
 Шелла,
 расческой.

Был проведен эксперимент для выявления самой быстрой и самой


медленной сортировки.
Литература
1. Кнут Д. Э. Искусство программирования. Том 3. Сортировка и поиск = The Art
of Computer Programming. Volume 3. Sorting and Searching / под ред. В. Т.
Тертышного (гл. 5) и И. В. Красикова (гл. 6). – 2-е изд. – Москва: Вильямс,
2007. – Т. 3. – 832 с.
2. Сайт Algolist. Сортировка выбором – http://algolist.manual.ru/sort/select_sort.php
3. Сайт Algolist. Сортировка пузырьком –
http://algolist.manual.ru/sort/bubble_sort.php.
4. Сайт Algolist. Сортировка вставками -
http://algolist.manual.ru/sort/insert_sort.php
5. Сайт Algolist. Сортировка слиянием -
http://algolist.manual.ru/sort/merge_sort.php
6. Сайт Algolist. Сортировка Хоара - http://algolist.manual.ru/sort/shell_sort.php
7. Сайт Algolist. Сортировка Шелла - http://algolist.manual.ru/sort/shell_sort.php
8. Сайт Википедия. Сортировка расческой -
https://ru.wikipedia.org/wiki/Сортировка_расчёской
Приложение
Исходный код программы:

#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <io.h>
#include <locale.h>
#include <string.h>
#include <iostream>
#include <cstdlib>

#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable:4996)

typedef struct
{
char name[260];
char date[30];
long size;
} ELEMENT;

void KapitanovBubbleSort(ELEMENT * mas, int down, int up, int mode)


{
bool flag = true;

for (int i = down; flag; i++)


{
flag = false;
for (int j = down; j < up - i; j++)
if ((mas[j].size < mas[j + 1].size) && (mode == -1) || (mas[j].size >
mas[j + 1].size) && (mode == 1))
{
ELEMENT tmp = mas[j];
mas[j] = mas[j + 1];
mas[j + 1] = tmp;
flag = true;
}
}
}

void SelectionSort(ELEMENT * mas, int down, int up, int mode)


{
for (int i = down; i < up; i++)
{
int maxim = mas[i].size;
int num = i;
for (int j = i + 1; j < up + 1; j++)
if ((mas[j].size > maxim) && (mode == -1) || (mas[j].size < maxim) &&
(mode == 1))
{
maxim = mas[j].size;
num = j;
}
ELEMENT tmp = mas[num];
mas[num] = mas[i];
mas[i] = tmp;
}
}

int BinarySearch(ELEMENT * mas, int down, int up, int mode, int insert)
{
while (down < up)
{
int mid = int(up + (down - up) / 2.0);
if ((mas[mid].size < insert) && (mode == -1) || (mas[mid].size > insert) && (mode
== 1))
up = mid;
else if ((mas[mid].size > insert) && (mode == -1) || (mas[mid].size < insert) &&
(mode == 1))
down = mid + 1;
else
{
up = mid;
down = mid;
}
}
return up;
}

void InsertionSort(ELEMENT * mas, int down, int up, int mode)


{
for (int i = down + 1; i < up + 1; i++)
{
if ((mas[i].size > mas[i - 1].size) && (mode == -1) || (mas[i].size < mas[i -
1].size) && (mode == 1))
{
int num;
if ((mas[i].size < mas[0].size) && (mode == -1) || (mas[i].size >
mas[0].size) && (mode == 1))
num = BinarySearch(mas, down, i - 1, mode, mas[i].size);
else
num = down;
ELEMENT tmp = mas[i];
for (int j = i; j > num; j--)
mas[j] = mas[j - 1];
mas[num] = tmp;
}
}
}

void Merge(ELEMENT * mas, int down, int mid, int up, int mode)
{
ELEMENT * tmp = new ELEMENT[up - down + 1];
int i = down, j = mid + 1;

while ((i < mid + 1) && (j < up + 1))


if ((mas[i].size < mas[j].size) && (mode == -1) || (mas[i].size > mas[j].size) &&
(mode == 1))
{
tmp[i + j - down - mid - 1] = mas[j];
j++;
}
else
{
tmp[i + j - down - mid - 1] = mas[i];
i++;
}
if (i == mid + 1)
for (; j < up + 1; j++)
tmp[i + j - down - mid - 1] = mas[j];
else
for (; i < mid + 1; i++)
tmp[i + j - down - mid - 1] = mas[i];
for (i = down; i < up + 1; i++)
mas[i] = tmp[i - down];
}

void MergeSort(ELEMENT * mas, int down, int up, int mode)


{
if (down < up)
{
int mid = int(up + (down - up) / 2.0);
MergeSort(mas, down, mid, mode);
MergeSort(mas, mid + 1, up, mode);
Merge(mas, down, mid, up, mode);
}
}

void QuickSort(ELEMENT * mas, int down, int up, int mode)


{
int i = down, j = up, fixik = mas[int(up + (down - up) / 2.0)].size;

while (i <= j)
{
while ((mas[j].size < fixik) && (mode == -1) || (mas[j].size > fixik) && (mode ==
1))
j--;
while ((mas[i].size > fixik) && (mode == -1) || (mas[i].size < fixik) && (mode ==
1))
i++;
if (i <= j)
{
ELEMENT tmp = mas[i];
mas[i] = mas[j];
mas[j] = tmp;
i++;
j--;
}
}
if (down < j)
QuickSort(mas, down, j, mode);
if (up > i)
QuickSort(mas, i, up, mode);
}

int IncCount(int * inc, int len)


{
int i = -1, shift, shift_chet, shift_nechet;

shift = shift_chet = shift_nechet = 1;


do
{
i++;
if (i % 2 == 0)
{
inc[i] = 9 * shift - 9 * shift_chet + 1;
shift_chet *= 2;
shift_nechet *= 2;
}
else
inc[i] = 8 * shift - 6 * shift_nechet + 1;
shift *= 2;
} while (inc[i] * 3 < len);
if (i == 0)
return 0;
else
return i - 1;
}

void ShellSort(ELEMENT * mas, int down, int up, int mode)


{
int * inc = new int[int(log2(up + 1))];
int index = IncCount(inc, up + 1);

for (int i = index; i >= 0; i--)


for (int j = inc[i]; j < up + 1; j++)
{
int k;
ELEMENT tmp = mas[j];
for (k = j - inc[i]; (k >= down) && ((mas[k].size < tmp.size) && (mode ==
-1) || (mas[k].size > tmp.size) && (mode == 1)); k -= inc[i])
mas[k + inc[i]] = mas[k];
mas[k + inc[i]] = tmp;
}
}

void CombSort(ELEMENT * mas, int down, int up, int mode)


{
const float factor = 1.247;

for (int i = int((up + 1) / factor); i >= 1; i = int(i / factor))


{
for (int j = down; j < up + 1 - i; j++)
if ((mas[j].size < mas[j + i].size) && (mode == -1) || (mas[j].size >
mas[j + i].size) && (mode == 1))
{
ELEMENT tmp = mas[j];
mas[j] = mas[j + i];
mas[j + i] = tmp;
}
}
KapitanovBubbleSort(mas, down, up, mode);
}

void main()
{
setlocale(LC_ALL, "Rus");
struct _finddata_t c_file;
intptr_t hFile;
ELEMENT * file = NULL;
char path[200];

printf("Enter the path to the directory:\n");


gets_s(path);
strcat(path, "\\*.*");
if ((hFile = _findfirst(path, &c_file)) == -1L)
printf("No files in current directory!\n");
else
{
printf("\nFILE DATE %24c SIZE\n", ' ');
printf("---- ---- %24c ----\n", ' ');
int count = 0;
do
{
count++;
} while (_findnext(hFile, &c_file) == 0);
file = (ELEMENT *)malloc((count) * sizeof(ELEMENT));
count--;
hFile = _findfirst(path, &c_file);
int i = -1;
do
{
char buffer[30];
i++;
ctime_s(buffer, _countof(buffer), &c_file.time_write);
printf("%-12.12s %.24s %10ld\n", c_file.name, buffer, c_file.size);
strcpy(file[i].name, c_file.name);
strcpy(file[i].date, buffer);
file[i].size = c_file.size;
} while (_findnext(hFile, &c_file) == 0);
_findclose(hFile);

void((*Sort[7]))(ELEMENT * mas, int down, int up, int mode);


Sort[0] = KapitanovBubbleSort;
Sort[1] = SelectionSort;
Sort[2] = InsertionSort;
Sort[3] = MergeSort;
Sort[4] = QuickSort;
Sort[5] = ShellSort;
Sort[6] = CombSort;

short next_sort;
do
{
printf("\nSelect the sort:\n");
printf("0 - Bubble Sort\n");
printf("1 - Selection Sort\n");
printf("2 - Binary Insertion Sort\n");
printf("3 - Merge Sort\n");
printf("4 - Quick Sort\n");
printf("5 - Shell Sort\n");
printf("6 - Comb Sort\n");
short num_sort, mode;
scanf("%hd", &num_sort);
printf("How to sort?\n");
printf("1: in ascending order of size\n");
printf("-1: in descending order of size\n");
scanf("%hd", &mode);

clock_t time = clock();


Sort[num_sort](file, 0, count, mode);
time = clock() - time;
printf("\nFILE DATE %24c SIZE\n", ' ');
printf("---- ---- %24c ----\n", ' ');
for (int i = 0; i <= count; i++)
printf("%-12.12s %.24s %10ld\n", file[i].name, file[i].date,
file[i].size);
printf("\nTime: %d ms\n", int((double)time * 1000 / CLOCKS_PER_SEC));
printf("\nWant to sort files again?\n");
printf("1 - Sort again; 0 - Quit\n");
scanf("%hd", &next_sort);
} while (next_sort == 1);
}

printf("\nZzz...");
_getch();
free(file);
}