Отчет по практике. Отчёт по практике. Отчет по учебной практике Ст гр. П911 Орлов Г. Проверила Руководитель практики Таренко Л. Б

Название	Отчет по учебной практике Ст гр. П911 Орлов Г. Проверила Руководитель практики Таренко Л. Б
Анкор	Отчет по практике
Дата	31.05.2021
Размер	368.51 Kb.
Формат файла
Имя файла	Отчёт по практике.docx
Тип	Отчет #212314

УВO “Университет управления “ТИСБИ”

Кафедра информационных технологий

Отчет по учебной практике

Выполнил:

Ст.гр. П-911

Орлов Г.

Проверила

Руководитель практики:

Таренко Л.Б.
Содержание

Введение 3

Необходимо разработать программное приложение по обработке больших наборов данных с использованием инструментальных средств и компьютерных технологий: 3

Для реализации буду использовать язык разработки Pascal и бесплатную среду для разработки Lazarus, а также язык Java и среду разработки IntelliJ IDEA для реализации хеш-таблиц. 3

Тема.1 – Построение и обработка двоичных деревьев поиска 4

1.1 Постановка задачи: 4

1.2 Эффективный способ решения: 4

1.3 Программный код 6

1.4 Результаты тестирования 17

Рис.3 – Пример работы поиска 18

Рис.4 – Пример удаления не терминальной вершины (ключ = 2) 18

Рис.5 – Пример удаления терминальной вершины (ключ = 10) 19

Тема 2. Поиск в массиве данных при помощи Хэш-таблиц 20

2.1 Постановка задачи 20

2.2 Эффективный способ решения: 20

2.3 Блок схема 21

3.1 Постановка задачи: 29

3.2Эффективный способ решения 29

3.2.1Пузырьковая сортировка 29

3.2.2Сортировка вставками 29

3.2.3Сортировка выбором 29

3.2.4Быстрая сортировка 30

3.3Программная реализация 31

3.4Результаты тестирования 38

Выводы 41

Список литературы 42

Введение

Необходимо разработать программное приложение по обработке больших наборов данных с использованием инструментальных средств и компьютерных технологий:

Для реализации буду использовать язык разработки Pascal и бесплатную среду для разработки Lazarus, а также язык Java и среду разработки IntelliJ IDEA для реализации хеш-таблиц.
IntelliJ IDEA — интегрированная среда разработки программного обеспечения для многих языков программирования, в частности Java, JavaScript, Python, разработанная компанией JetBrains.

Lazarus — открытая среда разработки программного обеспечения на языке Object Pascal для компилятора Free Pascal. Основная цель — предоставление кроссплатформенных и свободных средств разработки в Delphi-подобном окружении (по аналогии с Harbour для Clipper).

Тема.1 – Построение и обработка двоичных деревьев поиска

1.1 Постановка задачи:

Необходимо разработать программу, которая будет иметь структуру двоичного дерева поиска и добавить в программу возможность построения деревьев с различными значениями. Добавить программе возможность: добавления собственных терминальных узлов, удаления терминальных и не терминальных узлов, поиск заданных ключей в двоичном дереве, а также добавить функцию вывода двоичного дерева в консоль с помощью трёх обходов (прямой, симметричный, обратный).

1.2 Эффективный способ решения:

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

Добавление новой вершины. При добавлении первым шагом является поиск в дереве места для размещения новой вершины. Это место всегда находится однозначно и зависит от текущего состояния дерева и значения добавляемого ключа.

Поиск должен определить адрес вершины, к которой должна быть присоединена новая вершина. Определить родительскую вершину можно двумя способами: циклический поиск и рекурсивный поиск;

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

Алгоритм:

Если находим место новому элементу.
Создаём узел и записываем ключ.
Иначе рекурсивно уходим влево.
Иначе рекурсивно уходим вправо.
Иначе обработка неуникального ключа (в данной задаче увеличение счетчика появлений данного ключа)

Вывод дерева в консоль в обратном порядке.

Правило обратного обхода:

Обработать левого потомка
Обработать правого потомка
Обработать корневую вершину

Вывод дерева в консоль в обратном порядке.

Используем правило симметричного обхода

Обработать левого потомка левого поддерева
Перейти к корневой вершине и обработать её
Перейти к правому поддереву и обработать его

1.3 Программныйкод

program project1;
type

pStree = ^TStree;
TStree = record //Инициализация структуры с необходимыми данными

Data, kol: integer;

left: pStree;

right: pStree;

end;
var //Объявление переменных

pKoren, pResult, pRoditel, pTemp: pStree;

menu: byte;

sData, NewData, kol_i: integer;
function Search(aData: integer): pStree; //Функция поиска

begin

if (pKoren = nil) then //Если указатель на корень равен налу то значит дерево пустое

WriteLn('Поиск не возможен, дерево пустое.')

else

begin

pTemp := pKoren; //записываем корень во временную структуру

Result := nil;

while (pTemp <> nil) do //Пока не дойдём до конца списка

begin

if (aData = pTemp^.Data) then //Сравниваем значения ключей

begin

WriteLn('Элемент найден: ', pTemp^.Data); //Если они равны то выводим и выходим

Result := pTemp;

break;

end

else if (aData < pTemp^.Data) then //Если искомый ключ меньше ключа в вершине переходим к левому потомку

begin

pRoditel := pTemp;

pTemp := pTemp^.left;

end

else

begin //Если искомый ключ больше ключа в вершине переходим к правому потомку

pRoditel := pTemp;

pTemp := pTemp^.right;

end;

end;

end;

end;
procedure AddNode(var pTemp: pStree; aData: integer); //Добавление терминального узла

begin

if (pTemp = nil) then //Если узел пуст

begin

New(pTemp); //выделяем память и записываем данные о левом и правом узле

pTemp^.Data := aData;

pTemp^.left := nil;

pTemp^.right := nil;

pTemp^.kol := 1;

kol_i := pTemp^.kol;

end

else if (aData < pTemp^.Data) then //Если узел не пустой и значение добавляемого ключа меньше значения в вершине, то рекурсивно переходим к левому потомку и начинаем его обработку

AddNode(pTemp^.left, aData)

else if (aData > pTemp^.Data) then // Если значение больше чем значение ключа в вершине рекурсивно переходим к правому потомку

AddNode(pTemp^.right, aData)

else

begin //добавление неуникального ключа

WriteLn('Такой ключ уже существует! Добавляю неуникальный ключ.');

New(pTemp);

pTemp^.Data := aData;

pTemp^.left := nil;

pTemp^.right := nil;

pTemp^.kol := kol_i + 1;

kol_i := pTemp^.kol;

end;

end;
procedure PreOrder(pTemp:pStree; tabs:integer); //Прямой метод обхода

var i:integer;

begin

if pTemp <> nil then //Если корень не пустой

begin

for i:=0 to tabs do Write(' '); //Выводим необходимое кол-во пробелов

WriteLn(' ',pTemp^.Data, ' (',pTemp^.kol,') '); // выводим ключ вершины

PreOrder(pTemp^.left, tabs + 4); // переходим к левому потомку

PreOrder(pTemp^.right, tabs + 4); //переходим к правому потомку

end;

end;
procedure PostOrder(pTemp:pStree; tabs:integer); // обратный обход

var i:integer;

begin

if pTemp <> nil then //Если вершина существует

begin

PostOrder(pTemp^.left, tabs + 4); //переходим к левому потомку

PostOrder(pTemp^.right, tabs + 4); //переходим к правому потомку

for i:=0 to tabs do Write(' '); //Выводим необходимое кол-во пробелов

WriteLn(' ',pTemp^.Data, ' (',pTemp^.kol,') '); //выводим информацию об узле

end;

end;
procedure StandartOrder(pTemp: pStree; tabs: integer); //Симетричный обход

var

i: integer;

begin

if (pTemp <> nil) then //Если вершина не пустая

with pTemp^ do //перебираем указатели

begin

StandartOrder(pTemp^.left, tabs + 4); //переходим к левому потомку

for i := 0 to tabs do //выводим необходимое кол-во пробелов

Write(' ');

WriteLn(' /');

for i := 0 to tabs do

Write(' ');

WriteLn(' ', pTemp^.Data, ' (', pTemp^.kol, ')'); //Выводим ключ вершины

for i := 0 to tabs do

Write(' ');

WriteLn(' \');

StandartOrder(pTemp^.right, tabs + 4); //Переходим к правому потомку

end;

end;
procedure Print; //Меню вывода

var printType:byte;

begin

WriteLn('1. Прямой обход');

WriteLn('2. Симметричный обход');

WriteLn('3. Обратный обход');

Write('Введите значение: ');

ReadLn(printType);

case printType of

1: PreOrder(pKoren, 0);

2: StandartOrder(pKoren, 0);

3: PostOrder(pKoren, 0);

end;

end;
procedure Pop(sData: integer); // Удаление узла

var //инициализация необходимых переменных

pRTemp, pLTemp: pStree;

LR, nData, dData: integer;

begin

if (Search(sData) <> nil) then //Если мы нашли ключ(который нужно удалить) в нашем дереве, начинаем процедуру удаления

begin

if (pTemp^.left = nil) and (pTemp^.right = nil) then

begin //если вершина терминальная

WriteLn;

WriteLn('Вершина терминальная, удаляю.');

WriteLn('Родителем является: ', pRoditel^.Data);

if pRoditel^.left = pTemp then

pRoditel^.left := nil;

if pRoditel^.right = pTemp then

pRoditel^.right := nil;

WriteLn('Успешно удалено.');

WriteLn;

end //если у вершины есть хотя бы один потомок

else if (pTemp^.left = nil) xor (pTemp^.right = nil) then

begin

WriteLn;

WriteLn('У вершины есть один потомок, удаляю безопасным методом.');

WriteLn('Родителем является: ', pRoditel^.Data);

if (pTemp^.left = nil) then

begin

pRoditel^.right := pTemp^.right;

end;

if (pTemp^.right = nil) then

begin

pRoditel^.left := pTemp^.left;

end;

WriteLn('Успешно удалено.');

WriteLn;

end

else if (pRoditel^.left <> nil) and (pRoditel^.right <> nil) then
begin //если у вершины есть оба потомка

WriteLn;

WriteLn('У вершины есть два потомка: удаляю методом замены.');

WriteLn('Левое поддерево: ', pTemp^.left^.Data);

WriteLn('Правое поддерево: ', pTemp^.right^.Data);

WriteLn('Родителем является: ', pRoditel^.Data);
//ищем самую левую вершину

//заходим в левое поддерево и спускаемся как можно ниже по правой стороне

pLTemp := pTemp^.left;

if pLTemp^.right <> nil then

while (pLTemp^.right <> nil) do

begin

if (pLTemp^.right = nil) then

break

else

pLTemp := pLTemp^.right;

end;

WriteLn('Самая правая вершина в левом поддереве: ', pLTemp^.Data);
//ищем самую правую вершину

//заходим в правое поддерево и спускаемся как можно ниже по левой стороне

pRTemp := pTemp^.right;

//WriteLn(pRTemp^.left^.Data);//для отладки, потом удалить.

if pRTemp^.left <> nil then

while (pRTemp^.left <> nil) do

begin

if (pRTemp^.left = nil) then

break

else

pRTemp := pRTemp^.left;

end;

WriteLn('Самая левая вершина в правом поддереве: ', pRTemp^.Data);
//выбор вершины для замены

Write('Какую вершину желаете выбрать в качестве замены? (Л/П): ');

ReadLn(LR);

if (LR = pRTemp^.Data) then

begin

WriteLn('Удаляемая вершина - ', pTemp^.Data);

dData := pTemp^.Data;

//запоминаем ключ удаляемой вершины

WriteLn('Выбрана вершина-заменитель - ', pRTemp^.Data);

nData := pRTemp^.Data;

//запоминаем ключ вершины-заменителя

WriteLn('Cохранил ключ: ', nData);

Pop(pRTemp^.Data); //удаляем вершину-заменитель

pTemp := Search(dData);

if pTemp <> nil then

pTemp^.Data := nData

else

WriteLn('Непредвиденная ошибка, удаляемый элемент потерян.');

end;

if (LR = pLTemp^.Data) then

begin

WriteLn('Удаляемая вершина - ', pTemp^.Data);

dData := pTemp^.Data;

//запоминаем ключ удаляемой вершины

WriteLn('Выбрана вершина-заменитель - ', pLTemp^.Data);

nData := pLTemp^.Data;

//запоминаем ключ вершины-заменителя

WriteLn('Cохранил ключ: ', nData);

Pop(pLTemp^.Data); //удаляем вершину-заменитель

pTemp := Search(dData);

if pTemp <> nil then

pTemp^.Data := nData

else

WriteLn('Непредвиденная ошибка, удаляемый элемент потерян.');

end;

end;

end

else

begin

WriteLn;

WriteLn('404: Вершина не найдена.');

end;

WriteLn;

end;

begin

repeat //Меню пользователя

WriteLn('1. Поиск вершины с заданным значением ключа');

WriteLn('2. Добавление новой вершины');

WriteLn('3. Нарисовать дерево в консоли');

WriteLn('4. Удаление вершины с заданным значением ключа');

WriteLn('5. Выход из программы');

Write('Введите значение: ');

ReadLn(menu);

case menu of

1:

begin

WriteLn;

Write('Введите значение ключа для поиска: ');

ReadLn(sData);

pResult := Search(sData);

if (pResult = nil) then

begin

WriteLn('Ошибка 404: Узел не найден.');

WriteLn;

end;

end;

2:

begin

Write('Введите ключ добавляемого элемента: ');

ReadLn(NewData);

AddNode(pKoren, NewData);

WriteLn('Успешно добавлено.');

WriteLn;

end;

3: Print; //(pKoren, 0);

4:

begin

Write('Введите ключ вершины для удаления: ');

ReadLn(sData);

Pop(sData);

end;

end;

until menu = 5;

end.

1.4 Результаты тестирования

Рис.1 – Дерево после добавление 7-ми элементов

Рис.2 – Дерево после добавления 8-мого элемента с ключом 10

Рис.3 – Пример работы поиска

Рис.4 – Пример удаления не терминальной вершины (ключ = 2)

Рис.5 – Пример удаления терминальной вершины (ключ = 10)

Тема 2. Поиск в массиве данных при помощи Хэш-таблиц

2.1 Постановка задачи

Реализовать метод хэш-поиска с помощью метода разрешения конфликтов <<Метод пустых ячеек>>.

Входные данные – любые слова или символы. Размер хэш-таблицы задаётся в программе с помощью переменной size. В случае возникновения конфликта при вставки нового ключа, ищем первое свободное место по формуле hash = (hash + i) % size, где i = 0,1,2...

Программа должна иметь следующий функционал:

Иметь возможность добавления нового ключа в таблицу
Поиск заданного ключа в таблице
Вывод текущего состояния таблицы.

2.2 Эффективный способ решения:

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

Для решения конфликта используем алгоритм:

Вычисляем значение числовых кодов в строке и складываем их
Ищем остаток от деления суммы числовых кодов на размер массива
Если ячейка занята, пересчитываем по формуле code = (code + i) % size

2.3 Блок схема

Начало

Добавление элемента

Поиск ключа в таблице

Получаем числовое значение введённого пользователем слова

Запрашиваем у пользователя выбор из меню

Да

Такого ключа нет

Ячейка свободна?

Пересчитываем ключ по формуле

Записываем ключ в ячейку

Получаем числовое значение введённого пользователем слова

Перебираем массив

Ячейка занята?

Выводим ячейку

Пересчитываем значение ключа по формуле

нет

нет

Да

Ключ найден

Равно ли значение ячейки и введённое пользователем значение?

Свободна ли ячейка?

Да

нет

Вывод таблицы

Да

Да

нет

нет

Свободна ли ячейка?

2.4 Программная реализация:

import java.util.Scanner;
class Hash{ //класс для хранения ключей

private String key;

public Hash (String key){

this.key=key;

}

public String getKey(){

return key;

}

public void setKey(String key){

this.key=key;

}

}
class HashTable {

//массив для хранения элементовprivate

Hash[] table; //Массив классов который хранит ключи

//количество элементов в таблице

private int count;

//размер таблицы

private int size;

public HashTable(int size) //Конструктор создания хэш таблицы

{

this.size = size;

table = new Hash[size];

}

public void insert(String key) { // метод для вставки ключей

if(this.table != null){

Hash hash = new Hash(key);

int hash1 = hash1(key);

if(count < table.length/2){ // Если элементов в массиве меньше половины и ячейка свободна,то просто добавляем

while(table[hash1] != null)

{

hash1++;

hash1 %= size;

}

table[hash1] = hash;

count++;

}else //Если элементов в массиве больше половины то рехешируем

{

Hash[] newTable = new Hash[this.table.length*2];

size = size*2;

System.out.println("Рехеширование. \n размер массива увеличен до: " + size );

for(int i=0; i
newTable[i] = this.table[i];

}

this.table= newTable;

while(table[hash1] != null)

{

hash1++;

hash1 %= size;

}

table[hash1] = hash;

count++;

}

}}

public void print() //метод для печати таблицы в консоль

{

for(int i = 0; i < size; i++)

if(table[i] != null) //печатаем только те ячейки в которых есть ключи

System.out.println(i + " " + table[i].getKey());

}

public Hash find(String key) // метод поиска слова в таблице

{

int hash1 = hash1(key); // вычисляем значение хэша

while(table[hash1] != null) // перебираем значения ячеек начиная с первоначального значения

{

if(table[hash1].getKey().equals(key)) Если нашли то возвращаем ячейку

return table[hash1];

hash1++; //продолжаем перебирать ячейки и искать подходящий ключ

hash1 = hash1 % size;

}

return null; //Возвращаем нал если не нашли

}

public int find2(String key){

for (int i = 0; i < count; i++) {

if (table[i].getKey().equals(key)) {

return i;

}

}

return (-1);

}

private int hash1(String key)

{

int hash1 = 0;

for(int i = 0; i < key.length(); i++)

hash1 = (31 * hash1 + key.charAt(i)) % size;

return hash1;

}

}
class Menu { //Меню для пользователя

Scanner scan = new Scanner(System.in);

String s = "";

int x = 0;

String name;

HashTable ht = new HashTable(10);

public void mainMenu() {

while (!"4".equals(s)) {

System.out.println("1. Добавить элемент");

System.out.println("2. Найти элемент");

System.out.println("3. Напечатать таблицу на экран");

System.out.println("4. Выход");

s = scan.next();

try {

x = Integer.parseInt(s);

} catch (NumberFormatException e) {

System.out.println("Неверный ввод");

}

switch (x) {

case 1:

System.out.println("Введите строку:");

name = scan.next();

ht.insert(name);

break;

case 2:

System.out.println("Введите строку для поиска:");

name = scan.next();

Hash hash = ht.find(name);

if(hash != null)

System.out.println("Элемент "+ name + " найден под ключом: "+ ht.find2(name));

else

System.out.println("Элемент "+ name + " не найден!");

break;

case 3:

ht.print();

break;

}

}}

}
public class Main { //Главная функция вызывающая меню

public static void main(String[] args) {

Menu menu = new Menu();

menu.mainMenu();

}

}

2.5 Результаты тестирования

Рис.1 – Добавление 3-х элементов с одинаковым хэш-кодом в таблицу

Рис.2 – Вывод таблицы на экран и пример поиска элементов которые есть в таблице

Рис.3 – Пример поиска элемента, которого не существует

Тема 3. Сортировка данных

3.1 Постановка задачи:

Реализовать программу, реализующую как простейшие методы сортировок, так и метод быстрой сортировки:

Пузырьковая сортировка
Сортировка вставками
Сортировка выбором
Быстрая сортировка

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

После завершения разработки программы необходимо выполнить сортировки всеми методами нескольких массивов с разным числом элементов (10, 100, 1000, 10000) и сравнить эффективность различных методов сортировки.

Эффективный способ решения
1. Пузырьковая сортировка

Алгоритм состоит из повторяющихся проходах по массиву. На каждом проходе сравниваются соседние элементы, и, если их порядок в неверный, то они меняются местами. За каждый проход по массиву минимум 1 элемент встаёт на своё место.

Сортировка вставками

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

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

Алгоритм:

Находим минимальный элемент из неотсортированных
Меняем этот элемент с первым из неотсортированных
Сортируем пока неотсортированных элементов не останется

Быстрая сортировка

Алгоритм:

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

Программная реализация

program SortMethods;

const

n = 10;

type

arr = array [1..n] of integer;

var

mas: arr;

sredniy, sravneniya, zamenis, i, j, k: integer;

menu: byte;

procedure Print;

begin

for i := 1 to k do

Write(mas[i]:4, ' ');

WriteLn;

WriteLn;

Write('Число сравнений: ', sravneniya, ' ');

WriteLn('Число перестановок: ', zamenis);

WriteLn;

end;
procedure BubbleSort;

var

Temp: integer;

begin

sravneniya := 0;

zamenis := 0;

for i := 2 to k do

begin

for j := k downto i do

begin

sravneniya := sravneniya + 1;

if mas[j - 1] > mas[j] then

begin

zamenis := zamenis + 1;

temp := mas[j - 1];

mas[j - 1] := mas[j];

mas[j] := temp;

end;

end;

end;

end;

procedure MetodVstavki;

var

temp: integer;

begin

sravneniya := 0;

zamenis := 0;

for i := 2 to k do

begin

temp := mas[i];

j := i - 1;

while (j > 0) and (temp < mas[j]) do

begin

mas[j + 1] := mas[j];

j := j - 1;

sravneniya := sravneniya + 1;

zamenis := zamenis + 1;

end;

mas[j + 1] := temp;

end;

end;
procedure MetodVibora;

var

temp, b: integer;

begin

sravneniya := 0;

zamenis := 0;

for i := 1 to k - 1 do

begin

b := i;

temp := mas[i];

for j := i + 1 to k do

begin

if mas[j] < temp then

begin

b := j;

temp := mas[j];

end;

sravneniya := sravneniya + 1;

end;

if mas[i] <> mas[b] then

zamenis := zamenis + 1;

mas[b] := mas[i];

mas[i] := temp;

end;

WriteLn;

end;

procedure BistrayaSortirovka;

var

temp: integer;

procedure QuickSort(left, right: integer);

begin

i := left;

j := right;

if mas[i] > mas[j] then

begin

temp := mas[i];

mas[i] := mas[j];

mas[j] := temp;

end;

if mas[(i + j) div 2] > mas[j] then

begin

temp := mas[(i + j) div 2];

mas[(i + j) div 2] := mas[j];

mas[j] := temp;

end;

if mas[i] > mas[(i + j) div 2] then

begin

temp := mas[i];

mas[i] := mas[(i + j) div 2];

mas[(i + j) div 2] := temp;

end;

sredniy := mas[(i + j) div 2];

repeat

sravneniya := sravneniya + 1;

while (mas[i] < sredniy) do

i := i + 1;

sravneniya := sravneniya + 1;

while (mas[j] > sredniy) do

j := j - 1;

if (i <= j) then

begin

zamenis := zamenis + 1;

temp := mas[i];

mas[i] := mas[j];

mas[j] := temp;

i := i + 1;

j := j - 1;

end;

until (i > j);

if (left < j) then

QuickSort(left, j);

if (i < right) then

QuickSort(i, right);

end;
begin

sravneniya := 0;

zamenis := 0;

QuickSort(1, k);

end;
procedure RandomMass;

begin

WriteLn;

for i := 1 to k do

mas[i] := random(130)-30;

for i := 1 to k do

Write(mas[i]:4, ' ');

ReadLn;

end;
begin

Randomize;

WriteLn;

k:= n;

repeat

begin

WriteLn('Выбор метода сортировки:');

WriteLn('1. Методом обмена');

WriteLn('2. Методом вставок');

WriteLn('3. Методом выбора');

WriteLn('4. Быстрая сортировка');

WriteLn('5. Выход');

Write('Введите значение: ');

ReadLn(menu);

WriteLn;

case menu of

1:begin

RandomMass;

BubbleSort;

Print;

end;

2: begin

RandomMass;

MetodVstavki;

Print;

end;

3: begin

RandomMass;

MetodVibora;

Print;

end;

4: begin

RandomMass;

BistrayaSortirovka;

Print;

end;

end;

end;

until menu = 5;

end.

Результаты тестирования

Рис.1 – Результаты тестирования с 10-ю элементами

Рис.2 – Сортировка Пузырьком на 100 элементов

Рис.3 – Сортировка вставкой на 100 элементов

Рис.4 – Сортировка выбором на 100 элементов

Рис.5 – Быстрая сортировка на 100 элементов

Рис.6 – Метод пузырька на 1000 элементов

Рис.7 – Метод вставки на 1000 элементов

Рис.8 – Метод выбора на 1000 элементов

Рис.9 – Быстрая сортировка на 1000 элементов

Рис.10 Метод пузырька на 10000 элементов

Рис.11 – метод вставки на 10000 элементов

Рис.12 – Быстрая сортировка на 10000 элементов

Выводы

Разработали программное приложение по обработке больших наборов данных с использованием инструментальных средств и компьютерных технологий.

Создали программу, которая может обрабатывать больше наборы данных с использованием двоичных деревьев поиска

Создали программу организующую хеш-поиск в большом наборе данных

Создали программу реализующую различные методы сортировки, протестировали её на больших и малых наборах данных.

Протестировали все созданные приложения и опытным путём убедились в том, что методы сортировки отличаются с эффективности.

Список литературы

Wiki.com
https://tproger.ru/translations/sorting-for-beginners/
Окулов, С. М. Основы программирования / С. М. Окулов. — 10-е изд. — Москва : Лаборатория знаний, 2020. — 337 c. — ISBN 978-5-00101-759-2. — Текст : электронный // Электронно-библиотечная система IPR BOOKS : [сайт]. — URL: http://www.iprbookshop.ru/6449.html (дата обращения: 26.03.2021)
Сеттер, Р. В. Изучаем Java на примерах и задачах / Р. В. Сеттер. — Санкт-Петербург : Наука и Техника, 2016. — 240 c. — ISBN 2227-8397. — Текст : электронный // Электронно-библиотечная система IPR BOOKS : [сайт]. — URL: http://www.iprbookshop.ru/44025.html (дата обращения: 26.03.2021)
Златопольский, Д. М. Программирование: типовые задачи, алгоритмы, методы / Д. М. Златопольский. — 4-е изд. — Москва : Лаборатория знаний, 2020. — 224 c. — ISBN 978-5-00101-789-9. — Текст : электронный // Электронно-библиотечная система IPR BOOKS : [сайт]. — URL: http://www.iprbookshop.ru/12264.html (дата обращения: 26.03.2021).
Тарасов, В. Н. Математическое программирование. Теория, алгоритмы, программы : учебное пособие / В. Н. Тарасов, Н. Ф. Бахарева. — Самара : Поволжский государственный университет телекоммуникаций и информатики, 2017. — 222 c. — ISBN 5-7410-0559-4. — Текст : электронный // Электронно-библиотечная система IPR BOOKS : [сайт]. — URL: http://www.iprbookshop.ru/73832.html (дата обращения: 26.03.2021)

Казань 2020