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

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

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

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

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

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

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

«Исследование технологии Speech Recognition»

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

Краснодар
2022
 1 Задания

Задание 1. Исследовать зависимость скорости пирамидальной

сортировки от степени упорядоченности входного массива и его размера.
Получить графики зависимости.
Задание 2. Исследовать зависимость скорости сортировки слиянием
от степени упорядоченности входного массива и его размера. Получить
графики зависимости

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

Для выполнения лабораторной работы был выбран язык C#, так как
данный язык прост в синтаксисе и прекрасно подходит для работы с
алгоритмами сортировки массивов.
В первом задании была исследована зависимость скорости
пирамидальной сортировки от степени упорядоченности входного массива и
его размера (см. рис. 1 и листинг 1).
Сортировка пирамидой использует бинарное сортирующее дерево.
Сортирующее дерево — это такое дерево, у которого выполнены условия:
Каждый лист имеет глубину либо d, либо d-1, d — максимальная
глубина дерева.
Значение в любой вершине не меньше (другой вариант — не больше)
значения её потомков.
Удобная структура данных для сортирующего дерева — такой массив
Array, что Array[0] — элемент в корне, а потомки элемента Array[i] являются
Array[2i+1] и Array[2i+2].
Алгоритм сортировки будет состоять из двух основных шагов:
1. Выстраиваем элементы массива в виде сортирующего дерева:
 Этот шаг требует O(n) операций.

2. Будем удалять элементы из корня по одному за раз и перестраивать

дерево. То есть на первом шаге обмениваем Array[0] и Array[n-1],
преобразовываем Array[0], Array[1], … , Array[n-2] в сортирующее дерево.
Затем переставляем Array[0] и Array[n-2], преобразовываем Array[0],
Array[1], … , Array[n-3] в сортирующее дерево. Процесс продолжается до тех
пор, пока в сортирующем дереве не останется один элемент. Тогда Array[0],
Array[1], … , Array[n-1] — упорядоченная последовательность.
Этот шаг требует O(n\log n) операций.

Рисунок 1 – График зависимости

Из рисунка 1 видно, что время сортировки неупорядоченного массива
самое долгое, а самое быстрое время сортировки у упорядоченного массива.
Листинг 1
public static int add2pyramid(int[] arr, int i, int N)
{
int imax;
int buf;
if ((2 * i + 2) < N)
{
if (arr[2 * i + 1] < arr[2 * i + 2]) imax = 2 * i + 2;
else imax = 2 * i + 1;
}
else imax = 2 * i + 1;
if (imax >= N) return i;
if (arr[i] < arr[imax])
{
buf = arr[i];
arr[i] = arr[imax];
arr[imax] = buf;
if (imax < N / 2) i = imax;
}
return i;
}

public static void Pyramid_Sort(int[] arr, int len)

{
//step 1: building the pyramid
for (int i = len / 2 - 1; i >= 0; --i)
{
long prev_i = i;
i = add2pyramid(arr, i, len);
if (prev_i != i) ++i;
}

//step 2: sorting
int buf;
for (int k = len - 1; k > 0; --k)
{
buf = arr[0];
arr[0] = arr[k];
arr[k] = buf;
int i = 0, prev_i = -1;
while (i != prev_i)
{
 prev_i = i;
i = add2pyramid(arr, i, k);
}
}

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

сортировки слиянием от степени упорядоченности входного массива и его
размера (см. рис. 2 и листинг 2)
Для решения задачи сортировки эти три этапа выглядят так:
Сортируемый массив разбивается на две части примерно одинакового
размера;
Каждая из получившихся частей сортируется отдельно, например —
тем же самым алгоритмом;
Два упорядоченных массива половинного размера соединяются в
один.
1.1. — 2.1. Рекурсивное разбиение задачи на меньшие происходит до
тех пор, пока размер массива не достигнет единицы (любой массив длины 1
можно считать упорядоченным).
3.1. Соединение двух упорядоченных массивов в один.
Основную идею слияния двух отсортированных массивов можно
объяснить на следующем примере. Пусть мы имеем два уже
отсортированных по возрастанию подмассива. Тогда:
3.2. Слияние двух подмассивов в третий результирующий массив.
На каждом шаге мы берём меньший из двух первых элементов
подмассивов и записываем его в результирующий массив. Счётчики номеров
элементов результирующего массива и подмассива, из которого был взят
элемент, увеличиваем на 1.
3.4. «Прицепление» остатка.
Когда один из подмассивов закончился, мы добавляем все оставшиеся
элементы второго подмассива в результирующий массив.
 Рисунок 2 – График зависимости

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

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

Листинг 2
public static void Merge(int[] array, int lowIndex, int middleIndex,
int highIndex)
{
var left = lowIndex;
var right = middleIndex + 1;
var tempArray = new int[highIndex - lowIndex + 1];
var index = 0;
while ((left <= middleIndex) && (right <= highIndex))
{
if (array[left] < array[right])
{
tempArray[index] = array[left];
left++;
}
else
{
tempArray[index] = array[right];
right++;
}
index++;
}
for (var i = left; i <= middleIndex; i++)
{
 tempArray[index] = array[i];
index++;
}
for (var i = right; i <= highIndex; i++)
{
tempArray[index] = array[i];
index++;
}
for (var i = 0; i < tempArray.Length; i++)
{
array[lowIndex + i] = tempArray[i];
}
}

//сортировка слиянием
public static int[] MergeSort(int[] array, int lowIndex, int
highIndex)
{
if (lowIndex < highIndex)
{
var middleIndex = (lowIndex + highIndex) / 2;
MergeSort(array, lowIndex, middleIndex);
MergeSort(array, middleIndex + 1, highIndex);
Merge(array, lowIndex, middleIndex, highIndex);
}
return array;
}
public static int[] MergeSort(int[] array)
{
return MergeSort(array, 0, array.Length - 1);
}

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