Методическое пособие по курсу Структуры данных и алгоритмы их обработки предназначено для студентов, обучающихся по направлениям Управление в технических системах

• Название: Методическое пособие по курсу Структуры данных и алгоритмы их обработки предназначено для студентов, обучающихся по направлениям Управление в технических системах
• Дата: 03.02.2019
• Размер: 269 Kb.
• Имя файла: kursovoy_3097592.doc
• Тип: Методическое пособие; #66227
• страница: 3 из 3

Пример выполнения курсового проекта

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

Осуществить исследование прямых методов сортировки:

- метод прямого выбора;

- метод прямой вставки;

- метод прямого обмена.

Исследование осуществить, используя массивы упорядоченных и неупорядоченных чисел по 10,100,1000 и 10000 элементов.
2 Краткая теория

При обработке данных важно знать и информационное поле данных, и размещение их в машине.

Различают внутреннюю и внешнюю сортировки:

- внутренняя сортировка - сортировка в оперативной памяти;

- внешняя сортировка - сортировка во внешней памяти.

Сортировка - это расположение данных в памяти в регулярном виде по их ключам. Регулярность рассматривают как возрастание (убывание) значения ключа от начала к концу в массиве.

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

При сортировке могут встретиться одинаковые ключи. В этом случае при сортировке желательно расположить после сортировки одинаковые ключи в том же порядке, что и в исходном файле. Это устойчивая сортировка.

Эффективность сортировки можно рассматривать с нескольких критериев:

- время, затрачиваемое на сортировку;

- объем оперативной памяти, требуемой для сортировки;

- время, затраченное программистом на написание программы.

Выделяем первый критерий. Можно подсчитать количество сравнений при выполнении сортировки или количество перемещений.

Пусть Н = 0,01n² + 10n - число сравнений. Если n < 1000, то второе слагаемое больше, если n > 1000, то больше первое слагаемое.

Т. е. при малых n порядок сравнения будет равен n², при больших n порядок сравнения - n.

Порядок сравнения при сортировке лежит в пределах

от 0 (n log n) до 0 (n²); 0 (n) - идеальный случай.

Различают следующие методы сортировки:

- базовые методы;

- улучшенные методы.

Базовые методы:

 1) метод прямого включения;

 2) метод прямого выбора;

 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).

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²).

В худшем случае сортировка прямым выбором дает порядок n², как и для числа сравнений, так и для числа перемещений.

 

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 Метод исследования

Данная курсовая работа заключается в исследовании базовых методов сортировки:- метода прямого выбора;- метода прямого включения;- метода прямого обмена.

Исследование заключается в следующем:

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

Вышеописанный способ применяется для массивов, состоящих из 10, 100, 1000 и 10000 упорядоченных и неупорядоченных элементов для всех методов сортировки.

 

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

 

5 Контрольный пример

Задание:

 Дан список, содержащий имена студентов и соответствующие им баллы рейтинга. Необходимо отсортировать данный список по убыванию баллов рейтинга.

Сортировка методом прямого включения:

До сортировки		После сортировки
Аркадий	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

 

6 Заключение

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

 

7 Приложение

 

Описание процедур, используемых в программе

 

UPOR	процедура генерирует упорядоченный по возрастанию массив чисел
NOTUPOR	процедура генерирует неупорядоченный (случайный) массив чисел
PR_CHOOSE	процедура осуществляет сортировку методом прямого выбора
PR_INS	процедура осуществляет сортировку методом прямой вставки
PR_OBM	процедура осуществляет сортировку методом прямого обмена
MAKE	процедура осуществляет исследование прямых методов сортировки
EXAMPLE	процедура выполняет контрольный пример (сортировку методом прямого включения)

Текст программы( на языке программирования Pascal)



{$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(' "Исследование прямых методов сортировки"');

textcolor(red);gotoxy(3,25);write('Esc - главное меню');

repeat

k:=readkey;

until k=#27;

end;

end;

until item=7;

end.

{*********************конец программы********************}

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

1.Фофанов О.Б. Алгоритмы и структуры данных Издательство Томского политехнического университета, 2014, 122с.

2. Вирт Н. Алгоритмы и структуры даны: Пер. с англ.,  СПб. : Невский Диалект, 2007, 350с.

3. Кормен Томас Х. и др. Алгоритмы: построение и анализ: Пер. с англ.,  М. : Издательский дом «Вильямс» , 2009, 1296 с.

4. Фаронов В.В. Delphi. Программирование на языке высокого уровня. Издательство «Питер». 2011, 640 с.

5. Бобровский С.И. Delphi 7. Учебный курс. Издательство «Питер». 2004, 736 с.

Курсовой проект обсужден на заседании кафедры автоматизации производства и информационных технологий и одобрен Ученым советом Коломенского института.

Автор-составитель: старший преподаватель И. Н. Филоненко