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

ФГБОУ ВО «Кубанский государственный технологический университет»

(ФГБОУ ВО КубГТУ)

Институт компьютерных систем и информационной безопасности

Кафедра информационных систем и программирования
Направление подготовки 09.04.04 Программная инженерия
Профиль Промышленное проектирование программных систем

СОВРЕМЕННЫЕ ПРОБЛЕМЫ ИНФОРМАТИКИ

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

«Разработка функций анализа текста»

Выполнил:
студент 2 курса
группы 20-КМ-ПР1
Овезов М.Н.

Краснодар
2022
 1 Задания
Задание 1. Разработать программу генерации массива с заданной
степенью упорядоченности элементов: 0 – неупорядоченный, 1 –
упорядоченный.
Задание 2. Исследовать зависимость скорости быстрой сортировки от
степени упорядоченности входного массива.
Задание 3. Исследовать влияние способа выбора опорного элемента
на скорость сортировки. Значение опорного элемента может не принадлежать
массиву.

2 Ход выполнения лабораторной работы

Для выполнения лабораторной работы был выбран язык C#, так как
данный язык прост в синтаксисе и прекрасно подходит для работы с
алгоритмами сортировки массивов.
В первом задании были разработана программа генерации массива с
заданной степенью упорядоченности элементов (см. рис. 1 и листинг 1)

Рисунок 1 – Генерация массива

 Из рисунка 1 видно, что на экран консоли был выведен
упорядоченный массив, так как было введено число 1.

Листинг 1
static void Main(string[] args)
{
int[] arr = new int[1000];
//заполняем массив случайными числами
Random rd = new Random();
for (int i = 0; i < arr.Length; ++i)
{
arr[i] = rd.Next(1, 101);
}

Console.Write("Получить упорядоченный (1) или

неупорядоченный (0) массив? ");
int data = Int32.Parse(Console.ReadLine());
Console.WriteLine();
if (data == 0)
{
foreach (int x in arr)
{
Console.Write(x + " ");
}
}
if (data == 1)
{
sorting(arr, 0, arr.Length - 1);
foreach (double x in arr)
{
Console.Write(x + " ");
}
}

Console.ReadLine();
}

Во втором задании была исследована зависимость скорости быстрой

сортировки от степени упорядоченности входного массива (см. рис. 2 и
листинг 2)
 Быстрая сортировка относится к алгоритмам «разделяй и властвуй».
Алгоритм состоит из трёх шагов:
1. Выбрать элемент из массива. Назовём его опорным.
2. Разбиение: перераспределение элементов в массиве таким
образом, что элементы меньше опорного помещаются перед ним, а больше
или равные после.
3. Рекурсивно применить первые два шага к двум подмассивам
слева и справа от опорного элемента. Рекурсия не применяется к массиву, в
котором только один элемент или отсутствуют элементы.
В наиболее общем виде алгоритм на псевдокоде (где A —
сортируемый массив, а low и high — соответственно, нижняя и верхняя
границы сортируемого участка этого массива) выглядит следующим образом:
algorithm quicksort(A, low, high) is
if low < high then
p:= partition(A, low, high)
quicksort(A, low, p - 1)
quicksort(A, p + 1, high)

Здесь предполагается, что массив A передаётся по ссылке, то есть

сортировка происходит «на том же месте», а неописанная функция partition
возвращает индекс опорного элемента.
Для выбора опорного элемента и операции разбиения существуют
разные подходы, влияющие на производительность алгоритма.
Возможна также следующая реализация быстрой сортировки:
algorithm quicksort(A) is
if A is empty
return A
pivot := A.pop() (извлечь последний или первый элемент из
массива)
lA := A.filter(where e < pivot) (создать массив с элементами
меньше опорного)
rA := A.filter(where e > pivot) (создать массив с элементами
больше опорного)
return quicksort(lA) + [pivot] + quicksort(rA)
 На практике она не используется, а служит лишь в образовательных
целях, так как использует дополнительную память, чего можно избежать.

Рисунок 2 – Зависимость скорости сортировки

Из рисунка 2 видно, что время сортировки неупорядоченного массива

самое долгое, а самое быстрое время сортировки у упорядоченного массива.

Листинг 2
public static void sorting(int[] arr, long first, long last)
{
int p = arr[(last - first) / 2 + first];
int temp;
long i = first, j = last;
while (i <= j)
{
while (arr[i] < p && i <= last) ++i;
while (arr[j] > p && j >= first) --j;
if (i <= j)
{
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
++i; --j;
}
}
if (j > first) sorting(arr, first, j);
if (i < last) sorting(arr, i, last);
}
 В третьем задании было исследовано влияние способа выбора
опорного элемента на скорость сортировки (см. рис. 3 и листинг 3).
В ранних реализациях, как правило, опорным выбирался первый
элемент, что снижало производительность на отсортированных массивах.
Для улучшения эффективности может выбираться средний, случайный
элемент или (для больших массивов) медиана первого, среднего и последнего
элементов. Медиана всей последовательности является оптимальным
опорным элементом, но её вычисление слишком трудоёмко для
использования в сортировке.

Рисунок 3 – Влияние способа выбора опорного элемента

Из рисунка 3 видно, что время сортировки с выбранным первым

элементом в качестве опорного самое долгое, в то время как со случайным
элементом – самое быстрое.

Листинг 3
static void Main(string[] args)
{
Stopwatch stopwatch = new Stopwatch();
Stopwatch stopwatch2 = new Stopwatch();
Stopwatch stopwatch3 = new Stopwatch();
int[] arr = new int[1000000];
int[] arr1 = new int[1000000];
int[] arr2 = new int[1000000];
//заполняем массив случайными числами
int temp = 0;
Random rd = new Random();
for (int i = 0; i < arr.Length; ++i)
{
temp = rd.Next(1, 101);
 arr[i] = temp;
arr1[i] = temp;
arr2[i] = temp;
}
stopwatch.Start();
sorting(arr, 0, arr.Length - 1);
stopwatch.Stop();
Console.WriteLine("Время сортировки c выбранным средним элементом
в качестве опорного: " + stopwatch.ElapsedTicks);

stopwatch2.Start();
sorting2(arr1, 0, arr1.Length - 1);
stopwatch2.Stop();
Console.WriteLine("Время сортировки c выбранным первым элементом
в качестве опорного: " + stopwatch2.ElapsedTicks);

stopwatch3.Start();
sorting2(arr2, 0, arr1.Length - 1);
stopwatch3.Stop();
Console.WriteLine("Время сортировки c выбранным случайным
элементом в качестве опорного: " + stopwatch3.ElapsedTicks);
Console.ReadLine();
}

3 Вывод
В результате выполнения лабораторной работы были получены и
укреплены знания по работе с алгоритмами сортировки одномерных
массивов.