Привет, сегодня поговорим про методическое руководство к курсовой работе структуры данных, обещаю рассказать все что знаю. Для того чтобы лучше понимать что такое
методическое руководство к курсовой работе структуры данных, алгоритмы , настоятельно рекомендую прочитать все из категории Структуры данных.
ВведениеКурсовая работа выполняется студентами специальности 22.04 в четвертом семестре.
Целью курсовой работы является закрепление основ и углубление знаний в области структур и алгоритмов обработки данных в ЭВМ.
Тематика заданий на курсовую работу, приведенных в данных методических указаниях, может быть дополнена, расширена, увязана с решением актуальных научно-исследовательских задач, выполняемых на кафедре.
1 Требования к курсовой работе
1.1 Тема курсовой работы выдается каждому студенту индивидуально. В коллективных работах, в которых принимают участие два и более студентов, четко определяются объем и характер работы каждого студента. В задании формулируется задача, метод ее решения.
1.2 Курсовая работа состоит из пояснительной записки, к которой прилагается дискета с отлаженными программами (пояснительная записка может быть выполнена в виде текстового файла в формате Microsoft Word).
1.3 В пояснительную записку должны входить:
- титульный лист (приложение Б);
- задание на курсовое проектирование (приложение А);
- реферат (ПЗ, количество таблиц, рисунков, схем, программ приложений, краткая характеристика и результаты работы);
- содержание:
а) постановка задачи исследования;
б) краткая теория по теме курсовой работы;
в) программная реализация исследуемых алгоритмов;
г) программа, с помощью которой проводилось исследование;
д) результаты проведенного исследования:
е) выводы;
- список использованной литературы;
- подпись, дата.
1.4 Пояснительная записка должна быть оформлена на листах формата А4, имеющих поля. Все листы следует сброшюровать и пронумеровать.
1.5 Исследование алгоритмов операций над структурами данных и методов сортировок и поиска проводить при следующих фиксированных количествах элементов в структурах: 10, 100, 1000, 10000.
1.6 Дополнительные условия выполнения курсовой работы выдаются руководителем работы.
2. Примерный перечень курсовых работ
1) Исследование стеков.
2) Исследование очередей.
3) Исследование кольцевых структур.
4) Исследование полустатических структур.
5) Исследование линейных одно- и двусвязных списков.
6) Исследование деревьев бинарного поиска.
7) Исследование методов сортировки включением.
8) Исследование методов сортировки выбором.
9) Исследование методов сортировки обменом.
10) Исследование методов сортировки с помощью деревьев.
11) Исследование улучшенных методов сортировки.
12) Исследование линейного, индексного и бинарного поисков.
13) Исследование методов оптимизации поиска.
14) Исследование задач поиска по дереву.
3. Пример выполнения курсовой работы
3.1 Постановка задачи
Осуществить исследование прямых методов сортировки:
- метод прямого выбора;
- метод прямой вставки;
- метод прямого обмена.
Исследование осуществить, используя массивы упорядоченных и неупорядоченных чисел по 10,100,1000 и 10000 элементов.
3.2 Краткая теория
При обработке данных важно знать и информационное поле данных, и размещение их в машине.
Различают внутреннюю и внешнюю сортировки:
внутренняя сортировка - сортировка в оперативной памяти;
внешняя сортировка - сортировка во внешней памяти.
Сортировка - это расположение данных в памяти в регулярном виде по их ключам. Регулярность рассматривают как возрастание (убывание) значения ключа от начала к концу в массиве.
Если сортируемые записи занимают большой объем памяти, то их перемещение требует больших затрат. Для того, чтобы их уменьшить, сортировку производят в
таблице адресов ключей, делают перестановку указателей, т.е. сам массив не перемещается. Это
метод сортировки таблицы адресов.При сортировке могут встретиться одинаковые ключи. В этом случае при сортировке желательно расположить после сортировки одинаковые ключи в том же порядке, что и в исходном файле. Это
устойчивая сортировка.
Эффективность сортировки можно рассматривать с нескольких критериев:
время, затрачиваемое на сортировку;
объем оперативной памяти, требуемой для сортировки;
время, затраченное программистом на написание программы.
Выделяем первый критерий. Можно подсчитать количество сравнений при выполнении сортировки или количество перемещений.
Пусть Н = 0,01n
2 + 10n - число сравнений. Если n < 1000, то второе слагаемое больше, если n > 1000, то больше первое слагаемое.
Т. е. при малых n порядок сравнения будет равен n
2, при больших n порядок сравнения - n.
Порядок сравнения при сортировке лежит в пределах
от 0 (n log n) до 0 (n
2); 0 (n) - идеальный случай.
Различают следующие методы сортировки:
строгие (прямые) методы;
улучшенные методы.
Строгие методы:
1) метод прямого включения;
2) метод прямого выбора;
3) метод прямого обмена.
Количество перемещений в этих трех методах примерно одинаково.
3.2.1 Сортировка методом прямого включенияНеформальный алгоритм
for i = 2 to n
x = a(i)
находим место среди а(1)…а(i) для включения х
next i
Программа на Паскале:
for i := 2 to n do
begin
x := a[i];
a[0] = x;
for j := i - 1 downto 1 do
if x < a[j]
then a[j + 1] := a[j]
else a[j + 1] := x;
end;
|
Эффективность алгоритма:Количество сравнений в худшем случае будет равно
(n - 1)(n - 1).
3.2.2 Сортировка методом прямого выбораРассматриваем весь ряд массива и выбираем элемент, меньший или больший элемента а(i), определяем его место в массиве - k, и затем меняем местами элемент а(i) и элемент а(k).
Программа на Паскале:
for i := 1 to n - 1 do
begin
x := a[i];
k := i;
for j := i + 1 to n do
if x > a[j] then
begin
k := j;
x := a[k];
end;
a[k] := a[i];
a[i] := x;
end; |
Эффективность алгоритма:Число сравнений М =
.
Число перемещений C
min = 3(n - 1), C
max = 3(n - 1)
(порядок n
2).
В худшем случае сортировка прямым выбором дает порядок n
2, как и для числа сравнений, так и для числа перемещений.
3.2.3 Сортировка с помощью прямого обмена (пузырьковая)Идея: n - 1 раз проходят массив снизу вверх. При этом ключи попарно сравниваются. Если нижний ключ в паре меньше верхнего, то их меняют местами.
Программа на Паскале:
for i := 2 to n do
for j := n downto i do
if a[j - 1] > a[j] then
begin
x := a[j - 1];
a[j - 1] := a[j];
a[j] := x;
end;
|
В нашем случае получился один проход “вхолостую”. Чтобы лишний раз не переставлять элементы, можно ввести флажок.
Улучшением пузырькового метода является шейкерная сортировка, где после каждого прохода меняют направление внутри цикла.
Эффективность алгоритма:число сравнений М =
,
число перемещений C
max = 3
.
3.3 Метод исследования
Данная курсовая работа заключается в исследовании прямых методов сортировки:
- метода прямого выбора;
- метода прямого включения;
- метода прямого обмена.
Исследование заключается в следующем:
берут три массива с одинаковым количеством элементов, но один из них упорядоченный по возрастанию, второй - по убыванию, а третий - случайный. Осуществляется сортировка данных массивов и сравнивается количество перемещений элементов при сортировке первого, второго и третьего массивов, а также сравнивается количество сравнений при сортировке.
Вышеописанный способ применяется для массивов, состоящих из 10, 100, 1000 и 10000 упорядоченных и неупорядоченных элементов для всех методов сортировки.
3.4 Результаты исследования
Сортировка 10 элементов: |
- упорядоченных по возрастанию |
метод |
прямого выбора |
прямой вставки |
прямого обмена |
сравнений |
45 |
45 |
45 |
перемещений |
11 |
33 |
33 |
- неупорядоченных (случайных) |
метод |
прямого выбора |
прямой вставки |
прямого обмена |
сравнений |
45 |
45 |
45 |
перемещений |
27 |
27 |
27 |
- упорядоченных по убыванию |
метод |
прямого выбора |
прямой вставки |
прямого обмена |
сравнений |
45 |
45 |
45 |
перемещений |
0 |
0 |
0 |
Сортировка 100 элементов: |
- упорядоченных по возрастанию |
метод |
прямого выбора |
прямой вставки |
прямого обмена |
сравнений |
4950 |
4950 |
4950 |
перемещений |
2643 |
4862 |
4862 |
- неупорядоченных (случайных) |
метод |
прямого выбора |
прямой вставки |
прямого обмена |
сравнений |
4950 |
4950 |
4950 |
перемещений |
2558 |
2558 |
2558 |
- упорядоченных по убыванию |
метод |
прямого выбора |
прямой вставки |
прямого обмена |
сравнений |
4950 |
4950 |
4950 |
перемещений |
0 |
0 |
0 |
Сортировка 1000 элементов: |
- упорядоченных по возрастанию |
метод |
прямого выбора |
прямой вставки |
прямого обмена |
сравнений |
499500 |
499500 |
499500 |
перемещений |
241901 |
498442 |
498442 |
- неупорядоченных (случайных) |
метод |
прямого выбора |
прямой вставки |
прямого обмена |
сравнений |
499500 |
499500 |
499500 |
перемещений |
244009 |
250366 |
250366 |
- упорядоченных по убыванию |
метод |
прямого выбора |
прямой вставки |
прямого обмена |
сравнений |
499500 |
499500 |
499500 |
перемещений |
0 |
0 |
0 |
Сортировка 10000 элементов: |
- упорядоченных по возрастанию |
метод |
прямого выбора |
прямой вставки |
прямого обмена |
сравнений |
49995000 |
49995000 |
49995000 |
перемещений |
25003189 |
49984768 |
49984768 |
- неупорядоченных (случайных) |
метод |
прямого выбора |
прямой вставки |
прямого обмена |
сравнений |
49995000 |
49995000 |
49995000 |
перемещений |
18392665 |
24986578 |
24986578 |
- упорядоченных по убыванию |
метод |
прямого выбора |
прямой ставки |
прямого обмена |
сравнений |
49995000 |
49995000 |
49995000 |
перемещений |
0 |
0 |
0 |
3.5 Контрольный пример
Задание:Дан список, содержащий имена студентов и соответствующие им баллы рейтинга. Об этом говорит сайт https://intellect.icu . Необходимо отсортировать данный список по убыванию баллов рейтинга.
Сортировка методом прямого включения:
До сортировки |
После сортировки |
Аркадий |
19 |
Артур |
20 |
До сортировки |
После сортировки |
Мурат |
17 |
Аркадий |
19 |
Руслан |
9 |
Александр |
18 |
Артур |
20 |
Владимир |
18 |
Евгений |
7 |
Мурат |
17 |
Михаил |
15 |
Казбек |
16 |
Александр |
18 |
Михаил |
15 |
Виталий |
14 |
Борис |
15 |
Сидор |
8 |
Денис |
14 |
Владимир |
18 |
Виталий |
14 |
Алексей |
6 |
Василий |
13 |
Казбек |
16 |
Петр |
10 |
Марат |
5 |
Руслан |
9 |
Борис |
15 |
Иван |
8 |
Геннадий |
2 |
Сидор |
8 |
Денис |
14 |
Евгений |
7 |
Василий |
13 |
Алексей |
6 |
Сидор |
3 |
Марат |
5 |
Петр |
10 |
Сидор |
3 |
Иван |
8 |
Геннадий |
2 |
3.6 Выводы
По результатам исследования можно утверждать, что лучшим из прямых методов сортировки является метод прямого выбора, так как он дает наименьшее количество сравнений и перемещений независимо от количества сортируемых элементов и их взаимного расположения в массиве.
3.7 Описание процедур, используемых в программе
UPOR |
процедура генерирует упорядоченный по возрастанию массив чисел |
NOTUPOR |
процедура генерирует неупорядоченный (случайный) массив чисел |
PR_CHOOSE |
процедура осуществляет сортировку методом прямого выбора |
PR_INS |
процедура осуществляет сортировку методом прямой вставки |
PR_OBM |
процедура осуществляет сортировку методом прямого обмена |
MAKE |
процедура осуществляет исследование прямых методов сортировки |
EXAMPLE |
процедура выполняет контрольный пример (сортировку методом прямого включения) |
Текст программы{$M 65000,65000,65000}
{Выделение памяти осуществляется для того, чтобы было возможно осуществлять исследование массива, содержащего 10000 элементов
***********************************************************
Данная программа является курсовой работой по дисциплине
'Структуры и
алгоритмы обработки данных'
на тему 'Прямые методы сортировки'
В работе исследуются методы:
- прямого выбора;
- прямого обмена;
- прямой вставки.
Для исследования используются массивы из 10,100,100,10000 элементов.
**********************************************************}
{ использование модулей для осуществления вывода на экран }
uses crt,crtext,dcrt;***************************************************}
{** процедура, генерирующая упорядоченный по возрастанию массив чисел**}
{*********************************************************}
procedure upor(a:array of integer;var a1:array of integer);
var
{i - счетчик в циклах}
i:integer;
begin
{первый элемент принимает значение 1}
a[0]:=1;
for i:=1 to high(a) do
begin
{каждый последующий элемент принимает значение,
равное значению предыдущего элемента + случайное число}
a[i]:=a[i-1]+random(2);
end;
for i:=0 to high(a) do
a1[i]:=a[i];
end;
{*********************************************************}
{** процедура, генерирующая не упорядоченный (случайный) массив чисел**}
{*********************************************************}
procedure notupor(a:array of integer;var a1:array of integer);
var
{i - счетчик в циклах}
i:integer;
begin
for i:=0 to high(a) do
begin {элемент массива принимает случайное значение из диапазона 0 <= a[i] < 9999}
a[i]:=random(9999);
end;
for i:=0 to high(a) do
a1[i]:=a[i];
end;
{*********************************************************}
{***** процедура, осуществляющая сортировку методом прямого выбора***}
{*********************************************************}
procedure pr_choose(a:array of integer;var a1:array of integer;var k,k1:longint);
var
{i,j - счетчики в циклах}
i,j:integer;
{x - переменная для осуществления обмена между a[i] и a[j]}
x:integer;
begin
{k1 - переменная для подсчета количества сравнений
k - переменная для подсчета количества перемещений}
k:=0;k1:=0;
{high(a) - функция, возвращающая номер последнего элемента массива}
for i := 0 to high(a) - 1 do
begin
for j := i + 1 to high(a) do
begin
k1:=k1+1;
if a[i] < a[j] then
begin
k:=k+1;
{перестановка i-го с j-м элементом с помощью переменной x}
x:=a[i];
a[i]:=a[j];
a[j]:=x;
end;
end;
end;
for i:=0 to high(a) do
a1[i]:=a[i];
end;
{**********************************************************
***** процедура, осуществляющая сортировку методом прямого *
*************** обмена(метод пузырька) *********************
**********************************************************}
procedure pr_obm(a:array of integer;var a1:array of integer;var k,k1:longint);
var
{i,j - счетчики в циклах}
i,j:integer;
{x - переменная для осуществления обмена между a[j-1] и a[j]}
x:integer;
begin
{k1 - переменная для подсчета количества сравнений
k - переменная для подсчета количества перемещений}
k:=0;k1:=0;
for i := 1 to high(a) do
begin
for j := high(a) downto i do
begin
k1:=k1+1;
if a[j - 1] < a[j] then
begin
k:=k+1;
{обмена содержимым элементов массива a[j-1] и a[j]
с помощью переменной x}
x := a[j - 1];
a[j - 1] := a[j];
a[j] := x;
end;
end;
end;
for i:=1 to high(a) do
a1[i]:=a[i];
end;
{*********************************************************}
{*** процедура, осуществляющая сортировку методом прямого включения **}
{*********************************************************}
procedure pr_ins(a:array of integer;var a1:array of integer;var k,k1:longint);
var
{i,j - счетчики в циклах}
i,j:integer;
{x - переменная для осуществления обмена между a[i] и a[j]}
x:integer;
begin
{k1 - переменная для подсчета количества сравнений
k - переменная для подсчета количества перемещений}
k:=0;k1:=0;
for i := 1 to high(a) do
begin
x := a[i];
for j := i - 1 downto 0 do
begin
k1:=k1+1;
if x > a[j] then
begin
k:=k+1;
{обмена содержимым элементов массива a[j+1] и a[j]
с помощью переменной x}
a[j + 1] := a[j];
a[j]:=x;
end;
end;
end;
for i:=0 to high(a) do
a1[i]:=a[i];
end;
{**********************************************************
процедура, осуществляющая исследование методов сортировок для
*********** заданного массива чисел ***********************
**********************************************************}
procedure make(x1,n:integer;a,a1:array of integer;k:byte);
var
{количество перестановок}
kol_pr_ins, kol_pr_obm,kol_pr_choose:longint;
{количество сравнений}
kol_sr_ins, kol_sr_obm,kol_sr_choose:longint;
s:string;
begin
case k of
1:s:='упорядоченных по возрастанию';
2:s:='неупорядоченных (случайных)';
3:s:='упорядоченных по убыванию';
end;
{--------метод прямого включения---------}
pr_ins(a,a1,kol_pr_ins,kol_sr_ins);
{--------метод прямого обмена (метод пузырька)--------}
pr_obm(a,a1,kol_pr_obm,kol_sr_obm);
{---------метод прямого выбора----------}
pr_choose(a,a1,kol_pr_choose,kol_sr_choose);
{** вывод результата исследования **}
{вывод шапки таблицы}
gotoxy(3,x1);textcolor(cyan);textbackground(1);
writeln('Для ',high(a)+1,' ',s,' элементов:');
gotoxy(3,x1+1);textcolor(lightgreen);textbackground(1);
writeln('Методы: прямого включения прямого обмена прямого выбора');
{вывод полученных при исследовании данных}
gotoxy(3,x1+2);textcolor(white);write('перест.');
gotoxy(17,wherey);write(kol_pr_ins);
gotoxy(37,wherey);write(kol_pr_obm);
gotoxy(58,wherey);writeln(kol_pr_choose);
gotoxy(3,x1+3);write('сравн.');
gotoxy(17,wherey);write(kol_sr_ins);
gotoxy(37,wherey);write(kol_sr_obm);
gotoxy(58,wherey);writeln(kol_sr_choose);
str(high(a)+1,s);box(1,19,80,24,1,15,double,s+' элементов');
gotoxy(4,20);write('Сортировка ',s,' элементов по убыванию');
gotoxy(4,21);write('Сортируются ',s,' упорядоченных(по возрастанию) элементов');
gotoxy(4,22);write('Сортируются ',s,' неупорядоченных(случайных) элементов');
textbackground(lightgray);
textcolor(red);gotoxy(3,25);write('Esc - главное меню');
end;
{*********************************************
Пример сортировки методом прямого включения
Дан массив записей, содержащий:
-имя студента;
-кол-во баллов (рейтинг).
Необходимо отсортировать данный массив по
убыванию количества баллов у студента.
*********************************************}
procedure example;
type
{rec - запись, содержащая:
name - имя студента;
num - кол-во баллов (рейтинг).}
rec=record
name:string;
num:byte;
end;
var
{mas - массив записей rec}
mas:array[1..20] of rec;
{счетчики в циклах}
i,j:integer;
x:rec;
{переменные для подсчета количества сравнений и перемещений
во время сортировки}
k_sr,k_p:integer;
key:char;
begin
{переменные для подсчета количества сравнений и перемещений
во время сортировки}
k_sr:=0;k_p:=0;
randomize;
{Данный массив, содержащий имена студентов}
mas[1].name:='Иван';mas[2].name:='Петр';mas[3].name:='Сидор';
mas[4].name:='Василий';mas[5].name:='Денис';mas[6].name:='Геннадий';
mas[7].name:='Борис';mas[8].name:='Марат';mas[9].name:='Казбек';
mas[10].name:='Алексей';mas[11].name:='Владимир';mas[12].name:='Сидор';
mas[13].name:='Виталий';mas[14].name:='Александр';mas[15].name:='Михаил';
mas[16].name:='Евгений';mas[17].name:='Артур';mas[18].name:='Руслан';
mas[19].name:='Мурат';mas[20].name:='Аркадий';
{задание количества баллов у студента случайным образом}
for i:=1 to 20 do
mas[i].num:=random(19)+1;
{вывод пояснений}
getshadow;
textbackground(lightgray);
textcolor(red);gotoxy(15,1);write('Пример сортировки по убыванию методом прямого включения');
textbackground(lightgray);
textcolor(red); gotoxy(3,25); write('Esc - главное меню');
textcolor(red); gotoxy(65,25); write('F1 - задание');
box(58,0,80,25,1,15,double,'Статистика');
textcolor(lightmagenta);
gotoxy(59,3); write(' Сортировка методом ');
gotoxy(61,4); write('прямого включения.');
textcolor(white); gotoxy(59,5); write('---------------------');
box(31,0,57,25,1,15,double,'После сортировки');
textcolor(lightmagenta); gotoxy(32,3); write(' N Имя балл');
box(1,0,30,25,1,15,double,'До сортировки');
textcolor(lightmagenta); gotoxy(3,3); write('N Имя балл');
{вывод на экран исходного массива}
for i:=1 to 20 do
begin
textcolor(lightcyan); gotoxy(3,i+3); write(i);
textcolor(yellow); gotoxy(7,i+3); write(mas[i].name);
textcolor(lightred); gotoxy(25,i+3); writeln(mas[i].num);
end;
{сортировка по убыванию количества баллов}
for i := 2 to 20 do
begin
x := mas[i];
for j := i - 1 downto 1 do
begin
{k_sr - счетчик количества сравнений}
k_sr:= k_sr+1;
if x.num > mas[j].num then
begin
{k_p - счетчик количества перемещений}
k_p:=k_p+1;
{обмена содержимым элементов массива mas[j+1] и mas[j]
с помощью переменной x}
mas[j + 1] := mas[j];
mas[j]:=x;
end;
end;
end;
{вывод на экран отсортированного массива}
for i:=1 to 20 do
begin
textcolor(lightcyan); gotoxy(33,i+3); write(i);
textcolor(yellow); gotoxy(37,i+3); write(mas[i].name);
textcolor(lightred); gotoxy(52,i+3); writeln(mas[i].num);
end;
{вывод на экран количества сравнений и перестановок
в массиве, осуществленных во время сортировки}
textcolor(lightgreen); gotoxy(61,6); write('Сравнений:');
textcolor(lightgray); gotoxy(75,6); write(k_sr);
textcolor(lightgreen); gotoxy(61,8); write('Перестановок:');
textcolor(lightgray); gotoxy(75,8); write(k_p);
repeat
key:=' '; if keypressed then key:=readkey;
case key of
{#59 - код клавиши F1}
#59:begin
{вывод окна с заданием для контрольного примера}
{putshadow+box - вывод окна с тенью}
putshadow(15,7,65,15);box(15,7,65,15,lightgray,0,double,'Задание');
textcolor(red);
gotoxy(21,9); write('Дан список, содержащий фамилии студентов');
gotoxy(21,10); write('и их рейтинговые баллы. Необходимо от-');
gotoxy(21,11); write('сортировать данный список по убыванию ');
gotoxy(21,12); write('рейтинговых баллов.');
textcolor(yellow);gotoxy(50,15);write('Enter - отмена');
end;
{#13 - код клавиши Enter}
#13:getshadow;
end;
{#27 - код клавиши Esc}
until key=#27;
end;
{**********************************************************
************************ Основная программа **************
**********************************************************}
const
{массив строк - пунктов главного меню}
menu:array[1..7] of string=(' Пример сортировки ',' Исследование (10 эл-тов)',
' Исследование (100 эл-тов) ',
' Исследование (1000 эл-тов) ',
' Исследование (10000 эл-тов) ',
' О программе '
,' Выход ');
var
{массивы чисел, используемые для исследования}
a,a1:array[0..9] of integer; {10 - чисел}
b,b1:array[0..99] of integer; {100 - чисел}
c,c1:array[0..999] of integer; {1000 - чисел}
d,d1:array[0..9999] of integer; {10000 - чисел}
f:byte; {показатель того , какой массив
поступает в процедуру для упо-
рядочивания по убыванию:
1 - неупорядоченный (слу-
чайный);
2 - упорядоченный по воз-
растанию;
3 - упорядоченный по убы-
ванию}.
k:char;
item:byte;
begin
clrscr;cursoroff; {гашение курсора}
repeat
textbackground(0);clrscr;
{fill - процедура, заполняющая заданную область экрана заданными символами заданного цвета}
fill(lightgray,1,1,2,80,25,' ');
{menuv - процедура, выводящая на экран вертикальное меню}
menuv(25,10,menu,lightgray,black,red,lightgreen,yellow,'Сортировка',item,double);
{item - переменная, содержащая номер выбранного пункта меню}
case item of
1:example;
2:begin
{getshadow - процедура, убирающая тень от меню}
getshadow;
{** исследуются 10 упорядоченных по возрастанию элементов **}
{box - процедура, выводящая на экран окно}
box(1,0,80,18,1,15,double,'10 элементов');
{вызов процедуры upor, генерирующей упорядоченный по возрастанию
массив чисел}
upor(a,a);
{вызов процедуры make, осуществляющей исследование методов сортировки}
make(3,10,a,a1,1);
{** исследуются 10 неупорядоченных (случайных) элементов **}
{вызов процедуры notupor, генерирующей неупорядоченный(случайный) массив чисел}
notupor(a,a);
{вызов процедуры make, осуществляющей исследование методов сортировки}
make(8,10,a,a1,2);
{** исследуются 10 упорядоченных по убыванию элементов **}
{вызов процедуры make, осуществляющей исследование методов сортировки}
make(13,10,a1,a1,3);
{ожидание нажатия клавиши Esc}
repeat
k:=readkey;
until k=#27;
end;
3:begin
{getshadow - процедура, убирающая тень от меню}
getshadow;
{box - процедура, выводящая на экран окно}
box(1,0,80,18,1,15,double,'100 элементов');
{исследуются 100 упорядоченных по возрастанию элементов}
upor(b,b);
make(3,100,b,b1,1);
{исследуются 100 неупорядоченных (случайных) элементов}
notupor(b,b);
make(8,100,b,b1,2);
{исследуются 100 упорядоченных по убыванию элементов}
make(13,100,b1,b1,3);
repeat k:=readkey; until k=#27;
end;
4:begin
{getshadow - процедура, убирающая тень от меню}
getshadow;
box(1,0,80,18,1,15,double,'1000 элементов');
{исследуется 1000 упорядоченных по возрастанию элементов}
upor(c,c);
make(3,1000,c,c1,1);
{исследуется 1000 неупорядоченных (случайных) элементов}
notupor(c,c);
make(8,1000,c,c1,2);
{исследуется 1000 упорядоченных по убыванию элементов}
make(13,1000,c1,c,3);
repeat
k:=readkey;
until k=#27;
end;
5:begin
getshadow;
box(1,0,80,18,1,15,double,'10000 элементов');
{исследуются 10000 упорядоченных по возрастанию элементов}
upor(d,d);
make(3,10000,d,d1,1);
{исследуются 10000 неупорядоченных (случайных) элементов}
notupor(d,d);
make(8,10000,d,d1,2);
{исследуются 10000 упорядоченных по убыванию элементов}
make(13,10000,d1,d,3);
repeat
k:=readkey;
until k=#27;
end;
6:begin
{getshadow - процедура, убирающая тень от меню}
getshadow;
{ввод окна с темой курсовой работы}
box(10,5,70,15,lightgray,0,double,'О программе');
putshadow(10,5,70,15);
textcolor(brown);
gotoxy(12,7);write('Данная программа является курсовой работой по дисциплине');
gotoxy(21,8);write('"Алгоритмы и структуры обработки данных"');
gotoxy(30,9);write('Тема курсовой работы: ');
gotoxy(18,10);write(' "Исследование прямых методов сортировки"');
gotoxy(17,11);write('Курсовую работу выполнили студенты группы 95-ОА-21');
textcolor(red);gotoxy(3,25);write('Esc - главное меню');
repeat
k:=readkey;
until k=#27;
end;
end;
until item=7;
end.
{*********************конец программы********************}
На этом все! Теперь вы знаете все про методическое руководство к курсовой работе структуры данных, Помните, что это теперь будет проще использовать на практике. Надеюсь, что теперь ты понял что такое методическое руководство к курсовой работе структуры данных, алгоритмы
и для чего все это нужно, а если не понял, или есть замечания,
то не стесняйся, пиши или спрашивай в комментариях, с удовольствием отвечу. Для того чтобы глубже понять настоятельно рекомендую изучить всю информацию из категории
Структуры данных
Комментарии
Оставить комментарий
Структуры данных
Термины: Структуры данных