Очередь на Delphi
Понятие очереди как линейного списка данных, доступ к которому осуществляется по принципу "первый вошел, первый вышел". Способы реализации очереди: статический и динамический. Информационное содержание структуры Магазин. Руководство пользователя.
| Рубрика | Программирование, компьютеры и кибернетика |
| Вид | курсовая работа |
| Язык | русский |
| Дата добавления | 17.12.2014 |
| Размер файла | 715,6 K |
Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже
Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.
Размещено на http://www.allbest.ru/
МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РЕСПУБЛИКИ БЕЛАРУСЬ
БЕЛОРУССКИЙ НАЦИОНАЛЬНЫЙ ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ
Факультет информационных технологий и робототехники (ФИТР)
Кафедра программного обеспечения вычислительной техники
и автоматизированных систем
КУРСОВАЯ РАБОТА
по дисциплине: ”Основы алгоритмизации и программирования”
на тему: ”Очередь”
Выполнил: ст. гр. 107213 Абрамчук А.А.
Приняла: ст. преподаватель
Минск 2014
СОДЕРЖАНИЕ
Введение
1. ПРАКТИЧЕСКИЙ РАЗДЕЛ
1.1 Постановка задачи. Информационное содержание структуры Магазин
1.2 Описание программы
1.2.1 Основные теоретические сведения.
1.2.2 Статическая реализация очереди
1.2.3 Динамическая реализация очереди
1.3 Руководство пользователя
Выводы (заключение)
Список использованных источников
Приложение (тексты программ)
Скриншоты программы
Введение
Очередь представляет собой линейный список данных, доступ к которому осуществляется по принципу "первый вошел, первый вышел" (иногда сокращенно его называют методом доступа FIFO). Элемент, который был первым поставлен в очередь, будет первым получен из нее. Элемент, поставленный в очередь вторым, при поиске будет получен также вторым и т.д. Существует два способа реализации очереди - статический и динамический. При статической реализации элементы очереди хранятся в обычном массиве. Память под массив выделяется сразу и не изменяется по мере заполнения очереди. Преимуществом данного способа является скорость работы с очередью, т.к. элементы очереди располагаются в памяти друг за другом. Недостатком является возможность переполнения очереди при слишком большом количестве добавленных элементов. При динамической реализации каждый элемент очереди состоит из двух частей - информационной части и указателя на следующий элемент очереди. При таком способе реализации элементы располагаются в памяти произвольным образом. Преимуществом данного способа является то, что размеры очереди ограничены лишь размерами памяти и пустые элементы не хранятся в очереди, а освобождаются из памяти. Недостатком является медленная скорость работы с элементами при большом их количестве.
1. ПРАКТИЧЕСКИЙ РАЗДЕЛ
1.1 Постановка задачи
Разработать программу, реализующую алгоритм очереди (20 элементов). Задача решается в двух вариантах: статическом (на основе массива структур) и динамическом. Реализовать алгоритм кольцевой очереди на основе динамического списка. В качестве элемента очереди выбрать структуру, соответствующую индивидуальному варианту.
Предусмотреть заполнение очереди из файла (подготовить файл на 20 элементов). очередь данные информационный
Предусмотреть следующие операции:
1) Заполнение очереди
a) вручную
b) из файла (выбор файла, тек. папка, любая папка)
2) Удаление элемента из очереди
3) Очистка очереди
4) Вывод элементов, содержащихся в очереди
a) на экран
b) в файл
5) Сдвиг всех элементов очереди к началу при наличии пустых мест в начале очереди (для статического варианта)
Реализовать алгоритм обработки исключений.
Проанализировать достоинства и недостатки статического и динамического вариантов.
Продемонстрировать обработку ошибочных ситуаций (ввод данных другого типа, ввод пустых данных, переполнение очереди, пустая очередь).
Информационное содержание структуры Магазин:
1) Номер (ключ)
2) Название
3) Фамилия И.О. директора
4) Количество сотрудников
5) Годовой доход
1.2 Описание программы
1.2.1 Основные теоретические сведения
В данной курсовой работе реализовано 2 проекта: “Статическая очередь” и “Кольцевая очередь на основе динамического списка”.
Список - последовательность однородных элементов (называемых узлами), каждый из которых содержит ссылку на следующий (и/или предыдущий) элемент.
Списки делятся на линейные и кольцевые.
Списки делятся на односвязные и двусвязные.
Размер списка - количество элементов списка.
Список, в котором нет элементов, называется пустым списком.
Узлом списка называют элемент списка. Узел в связном списке состоит из двух частей. Первая часть содержит непосредственно данные, вторая часть содержит один или несколько адресов элементов, с которым связан данный узел.
Список, в узлах которого, задается адрес только одного (предыдущего или последующего) элемента, называются однонаправленным (односвязным).
Список, в узлах которого, задаются адреса и предыдущего и последующего элементов, называются двунаправленным (двусвязным).
Указатель на первый элемент списка - это адрес списка. Значение «NULL» (“0”) этого указателя означает, что список пуст.
Линейным списком называется последовательность однородных элементов (называемых узлами), каждый из которых (кромепоследнего)содержит ссылку на следующий (и/или предыдущий) элемент.
Линейный список может быть односвязным и двусвязным.
Линейные списки делятся на стеки, очереди, линейные списки.
Линейные списки - данные динамической структуры, которые представляют собой совокупность линейно связанных однородных элементов, для которых разрешается добавлять элементы между любыми двумя другими и удалять любой элемент. Списки отличаются от массивов тем, что доступ к их элементам осуществляется последовательно, в то время как массивы - структура данных произвольного доступа.
Кольцевой список - это линейный список, последний элемент которого содержит ссылку на первый элемент списка.
Кольцевой список также как линейный список может быть односвязным и двусвязным.
Очередь (Queue) - это частный случай линейного списка. Две основных операции с очередью - добавление элементов в конец (хвост) и удаление (выборка) из начала (головы) списка. При выборке элемент исключается из списка. Другие операции со стеком не определены.
Говорят, что очередь реализует принцип обслуживания FIFO (First In - First Out, первым пришел - первым ушел). Элементами очереди могут быть любые однотипные данные.
В программировании очереди применяются, например, в диспетчеризации задач операционной системой (например, очередь событий системы Windows и ей подобных), буферизованном вводе/выводе, в задачах моделирования массового обслуживания (например, обслуживания клиентов в банках).
Очередь напоминает людей, выстроенных в ряд. Человек, стоящий первым, обслуживается раньше других., а затем покидает очередь. Новые люди могут становиться только в конец, или хвост очереди. Операции над очередью выполняются только с концов. Очередь проще всего представить себе, постояв в ней час-другой )
Базовые операции над очередью:
· создать пустую очередь;
· уничтожить очередь;
· определить, пуста ли очередь;
· добавить в очередь новый элемент, новый элемент помещается в хвост очереди;
· удалить (выбрать) из очереди элемент, элемент удаляется из головы очереди;
· извлечь (получить) из очереди элемент, поставленный туда раньше всех
Программная реализация очереди возможна двумя способами:
· статически с помощью массива
· динамически с помощью механизма указателей
1.2.2 Статическая реализация очереди
Для реализации очереди надо объявить массив и две переменные - указатель начала очереди first и указатель конца очереди last. Будем считать, что очередь-массив заполняется (растет) слева-направо от первых элементов массива к последним. Тогда указатель first будет определять первую занятую ячейку массива, а указатель last - последнюю занятую ячейку. Тогда пустую очередь определим как first = last = 0 (индексация элементов массива начинается с 0), и при каждом добавлении нового элемента переменная last увеличивается на 1, а при удалении на 1 увеличивается указатель first. Последовательность операций для массива из пяти элементов показана на следующей схеме:
1. Пустая очередь: first = last = 0
Начало Конец
очереди очереди
---------------------------------->
1 2 3 4 5
|
|
|
|
|
|
2. Добавлен первый элемент М1, first = 1, last = 1
|
ММ1 |
|
|
|
|
3. Добавлен второй элемент М2, first = 1, last = 2
|
1М1 |
ММ2 |
4. Добавлен третий элемент М3, first = 1, last = 3
|
1М1 |
ММ2 |
ММ3 |
5. Удален первый элемент М1, first = 2, last = 3
|
3М2 |
0М3 |
6. Удален второй элемент М2, first = 3 , last = 3
|
0М3 |
7. Добавлен четвертый элемент М4, first = 3, last = 4
|
0М3 |
4М4 |
Рассмотренная выше простейшая реализация очереди-массива имеет один существенный недостаток: освобождающиеся при удалении ячейки в начале массива НЕ используются при последующих добавлениях, и поэтому при интенсивном использовании очереди быстро может возникнуть ситуация, когда указатель last выходит за пределы массива, тогда как в начале массива есть свободные ячейки.
Для устранения этого недостатка можно сдвигать все элементы влево к началу массива, что при большом числе элементов в очереди может привести к большим вычислительным затратам. Более эффективно использовать так называемую кольцевую очередь, в которой при дотижении указателем last конца массива добавление производится в начало массива.
В программе реализации очереди на основе массива реализованы функции показанные в таблице 1.
Таблица 1 - Список функций программы
|
Название функции |
Описание |
|
|
procedure InitQueue(var que: TQueue); |
инициализация (очистка) очереди |
|
|
function IsEmpty(que: TQueue) : Boolean; |
очередь пуста? |
|
|
procedure EnQueue(var que: TQueue; new_mag: TMagazine_Rec); |
добавление элемента в хвост очереди |
|
|
function DeQueue(var que: TQueue): TMagazine_Rec; |
удаление элемента из головы очереди |
|
|
procedure ReMoveQueueToTop(var que: TQueue); |
сдвиг всех элементов очереди влево к нулевому индексу массива |
|
|
function PrintQueue(que: TQueue): string; |
печать очереди |
|
|
function Top(que: TQueue): TMagazine_Rec; |
прочитать элемент очереди с головы |
|
Сама очередь объявляется следующим образом:
// тип Очередь
TQueue = record
aMagazine: array[1..QUE_SIZE] of TMagazine_Rec;
first, last: Integer;
end;
где структура Magazine_rec имеет следующий вид:
const
QUE_SIZE = 20; // максимальное кол-во элементов в очереди
type
// тип Магазин
TMagazine_Rec = record
Mag_Num: Integer; // номер магазина
Mag_Name: string[30]; // наименование магазина
FIO_Dir: string[30]; // ФИО директора магазина
Kol_Sotr: Integer; // количество сотрудников
Dohod: Double; // годовой доход
end;
Добавление элемента в очередь
Если очередь не переполнена, т.е. индекс хвоста меньше максимально разрешенного количества, то увеличиваем индекс-указатель хвост очереди last на 1, и в эту позицию добавляем новый элемент new_mag
procedure EnQueue(var que: TQueue; new_mag: TMagazine_Rec);
begin
if que.last >= QUE_SIZE then
begin
raise EInvalidOperation.Create('Очередь заполнена.');
end;
Inc(que.last);
que.aMagazine[que.last] := new_mag;
end;
Удаление элемента из очереди происходит по следующему алгоритму:
1. проверить возможность удаления (в очереди есть элементы?);
2. извлечь элемент данных из массива по индексу-указателю на голову first, запомнить его в переменную Result для возврата;
3. увеличить указатель first на 1;
function DeQueue(var que: TQueue): TMagazine_Rec;
begin
if IsEmpty(que) then
raise EInvalidOperation.Create('Очередь пуста.');
Result := que.aMagazine[que.first];
Inc(que.first);
end;
где функция IsEmpty() делает проверку очереди на пустоту:
function IsEmpty(que: TQueue) : Boolean;
begin
Result := (que.last < que.first); // хвост меньше головы?
end;
Функция Сдвига элементов очереди перемещает непустые элементы массива в цикле начи-ная c головы и до хвоста на first позиций влево к началу массива, устанавливая first = 1 и last = количеству элементов в очереди:
procedure ReMoveQueueToTop(var que: TQueue);
var
i, kol_el : Integer;
begin
if not IsEmpty(que) then
if que.first > 1 then
begin
kol_el := que.last - que.first + 1;
for i := que.first to que.last do
begin
que.aMagazine[i - que.first + 1] := que.aMagazine[i];
end;
que.first := 1;
que.last := kol_el;
end;
end;
Очистка очереди вызывает функцию инициализации очереди сбрасывая индексы массива в начальные значения :
procedure InitQueue(var que: TQueue);
begin
que.first := 1; // индекс головы
que.last := 0; // индекс хвоста
end;
Функция Вывода очереди выводит данные ее элементов проходя в цикле от головы first до хвоста last:
function PrintQueue(que: TQueue): string;
const
CR = #13#10;
var
i : Integer;
begin
Result := '';
for i := que.first to que.last do
Result := Result
+ '--- №п/п ' + IntToStr(i) + ' --------------------' + CR
+ IntToStr(que.aMagazine[i].Mag_Num) + CR
+ que.aMagazine[i].Mag_Name + CR
+ que.aMagazine[i].FIO_Dir + CR
+ IntToStr(que.aMagazine[i].Kol_Sotr) + CR
+ FloatToStrF(que.aMagazine[i].Dohod, ffFixed, 10, 2) + CR;
Result := Result
+ '--- Конец очереди --------------------------------' + CR;
end;
1.2.3 Динамическая реализация очереди
До сих пор мы рассматривали только статические программные объекты. Этим термином обозначаются объекты, которые порождаются непосредственно перед выполнением программы, существуют в течение всего времени ее выполнения и размер значений которых не изменяется по ходу выполнения программы.
Поскольку статические объекты порождаются до выполнения программы и размер их значений можно выделить еще на этапе трансляции исходного текста программы на языке машины.
Однако использование при программировании только статических объектов может вызвать определенные трудности, особенно с точки зрения получения эффективной машинной программы, а такая эффективность бывает чрезвычайно важной при решении ряда задач. Дело в том, что иногда мы заранее не знаем не только размера значения того или иного программного объекта, но даже и того, будет существовать этот объект или нет. Такого рода программные объекты , которые возникают уже в процессе выполнения программы, называют динамическими объектами.
В языке ПАСКАЛЬ для работы с динамическими объектами предусматривается специальный тип данных - так называемый ссылочный тип. Значением этого типа является ссылка на какой - либо программный объект, по которой осуществляется непосредственный доступ к этому объекту. На машинном языке такая ссылка как раз и представляется указанием места в памяти соответствующего объекта.
В этом случае для описания действий над динамическими объектами каждому такому объекту в программе сопоставляется статическая переменная ссылочного типа - в терминах этих ссылочных переменных и описываются действия над соответствующими динамическими объектами.
Чтобы связать элементы динамической структуры между собой, в состав элемента помимо информационного поля входят поля указателей (связок с другими элементами структуры) .
Наиболее распространенными динамическими структурами являются связанные списки. Очередь представляет собой это частный случай линейного связного списка.
Каждый элемент очереди должен иметь ссылку на следующий за ним элемент, поэтому элемент очереди объявляется как структура с двумя полями - информационное поле и связующее поле. Для реализации операций с очередью также удобно завестие еще два поля указателя: first на начало очереди и last на конец очереди.
const
QUE_SIZE = 20; // максимальное кол-во элементов в очереди
type
// тип Магазин
TMagazine = Record
Mag_Num: Integer; // номер магазина
Mag_Name: string[30]; // наименование магазина
FIO_Dir: string[30]; // ФИО директора магазина
Kol_Sotr: Integer; // количество сотрудников
Dohod: Double; // годовой доход
end;
// односвязный список
PNode = ^TNode;
TNode = Record
Magazine: TMagazine;
next: PNode;
end;
TQueue = record
first, last : PNode;
count : Integer;
end;
Приведенная ниже схема элементов очереди отражает логический порядок следования элементов, физически же элементы могут находиться в любых свободных областях памяти.
|
Эл-т1 |
Эл-т2 |
Эл-т3 |
Эл-т4 |
Эл-т5 |
|||||
|
Next: 2 |
Next: 3 |
Next: 4 |
Next: 5 |
NULL |
|||||
|
first |
last |
Основные операции с динамической очередью:
· добавление нового элемента в конец очереди
· удаление элемента из начала очереди
· проверка отсутствия элементов в очереди
· проход по очереди от начала к концу
Для создания пустой очереди объявим в программе переменные
var
// переменные для работы с очередью
que : TQueue; // очередь
mag : TMagazine; // магазин
и вызовем функцию инициализации очереди в которой обнулим указатели и счетчик количества элементов:
procedure InitQueue(var que: TQueue);
begin
que.first := nil;
que.last := nil;
que.count := 0;
end;
Поскольку у нас по условию очередь циклическая то указатель last всегда будет указывать на узел first.
Пустоту очереди будем проверять равенством количества элементов // очередь пуста?
function IsEmpty(que: TQueue): Boolean;
begin
Result := (que.count = 0);
end;
А заполненность очереди будем проверять равенством количества элементов максимально разрешенному количеству:
// очередь заполнена?
function IsFull(que: TQueue): Boolean;
begin
Result := (que.count = QUE_SIZE);
end;
Функция добавления элемента в конец очереди принимает два аргумента: ссылку на очередь и добавляемые данные. Выполнение функции состоит из шести шагов:
1. запомнить текущий указатель на хвост;
2. выделить память для нового элемента с помощью стандартной функции new;
3. заполнить поле данных нового элемента данными из переданного аргумента;
4. изменить указатель next запомненного узла (бывшего хвоста) таким образом, чтобы он указывал на новый добавленный элемент;
5. изменить значение указателя next у нового хвоста на голову очереди first;
6. увеличить количество элементов очереди;
// добавление элемента в хвост очереди
procedure EnQueue(var que: TQueue; new_mag: TMagazine);
var
new_node, last_node : PNode;
begin
if IsFull(que) then
raise EInvalidOperation.Create('Очередь заполнена.');
last_node := que.last; // запомним последний узел
New(new_node);
que.last := new_node;
que.last.Magazine := new_mag;
if que.first = nil then
que.first := que.last;
if last_node <> nil then
last_node^.next := que.last;
que.last^.next := que.first; // замыкание на голову )
Inc(que.count);
end;
Функция удаления элемента из головы очереди получает два аргумента: ссылку на очередь и указатель на удаляемые данные. Выполнение функции состоит из четырех шагов:
1. запомнить указатель на голову;
2. запомнить удаляемые данные в переменную Result для возврата;
3. сместить указатель головы на следующий элемент очереди;
4. изменить указатель хвоста новую голову;
5. изменить значение указателя next у нового хвоста на голову очереди first;
6. освободить память удаленной головы
7. уменьшить количество элементов;
// удаление элемента из головы очереди
function DeQueue(var que: TQueue): TMagazine;
var
new_node: PNode;
begin
if IsEmpty(que) then
raise EInvalidOperation.Create('Очередь пуста!');
new_node := que.first;
Result := new_node^.Magazine; // возврат удаленного
que.first := new_node^.next;
que.last.next := que.first;
Dispose(new_node);
Dec(que.count);
if que.count = 0 then
begin
que.first := nil;
que.last := nil;
end;
end;
Для прохода по очереди от головы до хвоста необходимо:
1. ввести вспомогательную ссылочную переменную temp_node : PNode;
2. установить ее равной адресу головы: temp _node = que.first
3. организовать цикл в теле которого обработать очередной элемент с помощью указателя temp_node, затем перекинуть temp_node на следующий по его ссылке next;
4. крутить цикл пока не достигнем конца очереди last у которого указатель next указывает на голову first: temp _node = que.first
Этот алгоритм прохода используется при выводе очереди:
// вывод очереди на экран
function PrintQueue(que: TQueue): string;
const
CR = #13#10;
var
tmp_node : PNode;
i : Integer;
begin
Result := '';
i := 0;
if not IsEmpty(que) then
begin
tmp_node := que.first;
repeat
Inc(i);
Result := Result
+ '--- №п/п ' + IntToStr(i) + ' --------------------' + CR
+ IntToStr(tmp_node^.Magazine.Mag_Num) + CR
+ tmp_node^.Magazine.Mag_Name + CR
+ tmp_node^.Magazine.FIO_Dir + CR
+ IntToStr(tmp_node^.Magazine.Kol_Sotr) + CR
+ FloatToStrF(tmp_node^.Magazine.Dohod, ffFixed, 10, 2) + CR;
tmp_node := tmp_node^.next;
until tmp_node = que.first;
end;
end;
1.3 Руководство пользователя
Программа предназначена для работы со списком магазинов, организованном в виде очереди. Программа реализована в виде двух приложений на Delphi:
1) ArrayQ.exe - статическая очередь на основе массива структур со сдвигом элементов в начало массива;
2) LinkedQ.exe - кольцевая очередь на основе динамического списка.
Для запуска программы необходимо запустить соответствующий файл. После запуска программы выводится главное меню, в котором пользователю предлагается выбрать определенное действие:
Рис. 2.4.1. Главное окно программы.
Для добавления элемента в очередь нужно заполнить поля: № магазина, Наименование, ФИО директора, количество сотрудников, годовой доход и нажать кнопку [Добавить].
Для предотвращения ввода не числа в числовых полях «Номер магазина», «Количество сотрудников» и «Годовой доход» использованы элементы TmaskEdit и установлены соответствующие числовые маски.
Для удаления элемента из очереди нужно нажать кнопку [Удалить].
При удалении элементов из очереди начальные индексы массива освобождаются и в этом случае очередь можно сместить в начало массива, для этого нужно нажать кнопку [Сместить очередь в начало массива] (толко для очереди на основе массива).
Для загрузки очереди из файла следует нажать кнопку [Загрузить из файла] и выбрать текстовый файл. Для загрузки подготовлен текстовый файл Queue.txt заполненный данными по 20 магазинам.
Для сохранения данных в файл нужно нажать кнопку [Сохранить в файл] и указать имя сохраняемого файла.
Выводы (заключение)
Сравним производительность различных операций для списков с массивами. Основное преимущество массивов - возможность обратиться к произвольному элементу по его индексу. Для списка подобная операция потребует просмотра всех предшествующих элементов. Однако добавление в начало и середину массива, а также удаление из начала и середины требует сдвига всех элементов массива, расположенных после вставляемого (удаляемого). Для списка же производительность операций добавления и удаления не зависит ни от длины списка, ни от места вставки. Сортировка вставками в списке имеет такую же производительность, что и простые виды сортировок для массивов (например, пузырьковая сортировка или сортировка выбором).
Таким образом, если в задаче требуется структура с частыми операциями вставки и удаления в середине, следует предпочесть список, если же важнее быстрый доступ по индексу - следует выбрать массив. При выборе структуры следует также учитывать, что для организации односвязного списка на каждый элемент требуется одно поле связи, занимающее 4 байта (для массива подобные накладные расходы отсутствуют). С другой стороны, список может динамически расширяться во время работы программы, в то время как под массив отводится фиксированное количество элементов, которое необходимо указать на этапе компиляции.
В практической части была написана программа на языке Delphi, реализующая алгоритм очереди в двух вариантах:
1) статическая очередь на основе массива структур со сдвигом элементов в начало массива;
2) кольцевая очередь на основе динамического списка.
В программе был реализован стандартный набор операций выполняемых над очередями:
- добавление элемента;
- удаление элемента;
- вывод элементов;
- выгрузка/загрузка очереди в/из текстового файла.
Достоинство данной реализации стека состоит в том, что она скрыта в модуле, и клиентская программа работает со стеком только через его интерфейс. Это обстоятельство позволяет нам поменять реализацию стека с массива на список, не изменяя клиентскую программу.
Список использованных источников
1. Ахо, Альфред, В., Хопкрофт, Джон, Ульман, Джеффри, Д. Структуры данных и алгоритмы. -- М. : Издательский дом "Вильяме", 2000
2. Стивенс Р. Delphi. Готовые алгоритмы. Питер, 2004
3. Окулов С. Программирование в алгоритмах. БИНОМ. Лаб. Знаний, 2004
4. Бакнелл Дж. Фундаментальные алгоритмы и структуры данных в Delphi. Diasoft. 2003
5. Кэнту М. Delphi 7 для профессионалов. Питер. 2004
6. Павловская Т.А. Паскаль. Программирование на языке высокого уровня. Питер. 2007
Приложение (тексты программ)
1) Очередь на основе статического массива
// -----------------------------------------------------------------------------
// Курсовая работа на тему "Очередь"
// 1) Очередь на основе массива структур
//
// Информационное содержание структуры
// Магазин
// 1. Номер магазина(ключ)
// 2. Название магазина
// 3. Фамилия И.О. директора
// 4. Количество сотрудников
// 5. Годовой доход
// студента группы 107213 Абрамчука Антона Алексеевича
// -----------------------------------------------------------------------------
program ArrayQ;
uses
Forms,
ArrayQF in 'ArrayQF.pas' {MainForm},
ArrayQU in 'ArrayQU.pas';
{$R *.res}
begin
Application.Initialize;
Application.CreateForm(TMainForm, MainForm);
Application.Run;
end.
unit ArrayQF;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Buttons, Mask, Menus, StrUtils,
ArrayQU;
type
TMainForm = class(TForm)
OpenDialog1: TOpenDialog;
SaveDialog1: TSaveDialog;
btnInsert: TButton;
Memo1: TMemo;
btnSaveFile: TButton;
btnOpenFile: TButton;
lblMag_Num: TLabel;
edtMag_Num: TMaskEdit;
lblFIO_Dir: TLabel;
edtFIO_Dir: TEdit;
lblMag_Name: TLabel;
edtMag_Name: TEdit;
lblKol_Sotr: TLabel;
edtKol_Sotr: TMaskEdit;
lblDohod: TLabel;
edtDohod: TMaskEdit;
MainMenu1: TMainMenu;
mmFile: TMenuItem;
mmHelp: TMenuItem;
mnuClose: TMenuItem;
mnuHelp: TMenuItem;
btnDelete: TButton;
btnClearQue: TButton;
btnReMoveQueTop: TButton;
procedure FormCreate(Sender: TObject);
procedure btnSaveFileClick(Sender: TObject);
procedure btnOpenFileClick(Sender: TObject);
procedure btnInsertClick(Sender: TObject);
procedure mnuCloseClick(Sender: TObject);
procedure edtMag_NumChange(Sender: TObject);
procedure btnClearQueClick(Sender: TObject);
procedure btnDeleteClick(Sender: TObject);
procedure mnuHelpClick(Sender: TObject);
procedure btnReMoveQueTopClick(Sender: TObject);
procedure edtMag_NumEnter(Sender: TObject);
procedure edtMag_NumExit(Sender: TObject);
private
{ Private declarations }
procedure ClearFields();
procedure EnableDisableButton();
public
{ Public declarations }
end;
var
MainForm: TMainForm;
// переменные для работы с очередью
que : TQueue; // очередь
mag : TMagazine_Rec; // магазин
FileName_Zap : string;
File_Zap : TextFile;
implementation
{$R *.dfm}
procedure TMainForm.FormCreate(Sender: TObject);
begin
// очищаем поля
ClearFields();
InitQueue(que);
EnableDisableButton();
end;
// очистка полей
procedure TMainForm.ClearFields();
begin
edtMag_Num.Clear;
edtMag_Name.Clear;
edtFIO_Dir.Clear;
edtKol_Sotr.Clear;
edtDohod.Clear;
// и запрещаем кнопку вставки т.к. поля ввода пустые
btnInsert.Enabled := False;
end;
procedure TMainForm.btnInsertClick(Sender: TObject);
begin
// если поля не заполнены - отказать в добавлении записи
if (edtMag_Num.Text = '') then
begin
edtMag_Num.SetFocus;
ShowMessage('Заполните номер магазина');
Exit;
end
else if (edtMag_Name.Text = '') then
begin
edtMag_Name.SetFocus;
ShowMessage('Заполните наименование магазина');
Exit;
end
else if (edtFIO_Dir.Text = '') then
begin
edtFIO_Dir.SetFocus;
ShowMessage('Заполните ФИО директора магазина'); // выдать сообщение
Exit;
end
else if (edtKol_Sotr.Text = '') then
begin
edtKol_Sotr.SetFocus;
ShowMessage('Заполните кол-во сотрудников магазина'); // выдать сообщение
Exit;
end
else if (edtDohod.Text = '') then
begin
edtDohod.SetFocus;
ShowMessage('Заполните год. доход магазина'); // выдать сообщение
Exit;
end;
mag.Mag_Num := StrToInt(edtMag_Num.Text);
mag.Mag_Name := edtMag_Name.Text;
mag.FIO_Dir := edtFIO_Dir.Text;
mag.Kol_Sotr := StrToInt(edtKol_Sotr.Text);
mag.Dohod := StrToFloat(edtDohod.Text);
EnQueue(que, mag);
Memo1.Text := PrintQueue(que);
ClearFields();
// фокус на 1-ое поле
edtMag_Num.SetFocus;
EnableDisableButton();
end;
procedure TMainForm.btnSaveFileClick(Sender: TObject);
var
i : Integer;
begin
// Сохранить в файл
SaveDialog1.Title := 'Сохранить в файл'; // Изменение заголовка окна диалога
SaveDialog1.FileName := 'Queue.txt';
if SaveDialog1.Execute then // открытие окна диалога выбора файла
begin
FileName_Zap := SaveDialog1.FileName; // Имя выбранного в диалоге файла
AssignFile(File_Zap, FileName_Zap); // Связывание файловой переменной File_Zap с именем файла
Rewrite(File_Zap); // Создаем файл
for i := que.first to que.last do
begin
Writeln(File_Zap, IntToStr(que.aMagazine[i].Mag_Num));
Writeln(File_Zap, que.aMagazine[i].Mag_Name);
Writeln(File_Zap, que.aMagazine[i].FIO_Dir);
Writeln(File_Zap, IntToStr(que.aMagazine[i].Kol_Sotr));
Writeln(File_Zap, FloatToStrF(que.aMagazine[i].Dohod, ffFixed, 10, 2));
end;
CloseFile(File_Zap); // Закрытие файла
end;
end;
procedure TMainForm.btnOpenFileClick(Sender: TObject);
var
num_zap : Integer;
s : string;
first_el : integer;
begin
// кнопка Открыть файл (открытие существующего файла)
OpenDialog1.FileName := 'Queue.txt';
if OpenDialog1.Execute then // если в диалоге открытия нажата кнопка ОК
begin
FileName_Zap := OpenDialog1.FileName; // имя выбранного файла
AssignFile(File_Zap, FileName_Zap); // Связывание файловой переменной File_Zap с именем файла
Reset(File_Zap); // Открываем выбранный файл
InitQueue(que); // очистить очередь
Memo1.Clear; // очистить Memo
num_zap := 0; // счетчик записей в файле
// читаем пока не конец файла и кол-во не больше размера очереди
while (not eof(File_Zap)) and (num_zap <= QUE_SIZE) do
begin
num_zap := num_zap + 1; // увеличим счетчик считываемой записи
// Читаем из файла
Readln(File_Zap, s);
mag.Mag_Num := StrToInt(s);
Readln(File_Zap, s);
mag.Mag_Name := s;
Readln(File_Zap, s);
mag.FIO_Dir := s;
Readln(File_Zap, s);
mag.Kol_Sotr := StrToInt(s);
Readln(File_Zap, s);
mag.Dohod := StrToFloat(s);
EnQueue(que, mag);
Memo1.Text := PrintQueue(que);
ClearFields();
// фокус на 1-ое поле
edtMag_Num.SetFocus;
end;
CloseFile(File_Zap); // Закрытие файла
end;
// разблокировать кнопки если очередь не пуста
EnableDisableButton();
end;
// при вводе данных в поле разблокировать кнопку добавления
procedure TMainForm.edtMag_NumChange(Sender: TObject);
begin
btnInsert.Enabled := (edtMag_Num.Text <> '');
end;
procedure TMainForm.btnClearQueClick(Sender: TObject);
begin
// очистить очередь
InitQueue(que);
Memo1.Clear;
// запретить кнопки удаления т.к. очередь пуста
EnableDisableButton();
end;
procedure TMainForm.btnDeleteClick(Sender: TObject);
begin
mag := DeQueue(que);
Memo1.Text := PrintQueue(que);
// заполнить поля удаленной записью
edtMag_Num.Text := IntToStr(mag.Mag_Num);
edtMag_Name.Text := mag.Mag_Name;
edtFIO_Dir.Text := mag.FIO_Dir;
edtKol_Sotr.Text := IntToStr(mag.Kol_Sotr);
edtDohod.Text := FloatToStrF(mag.Dohod, ffFixed, 10, 2);
// фокус на 1-ое поле
edtMag_Num.SetFocus;
// запретить кнопки удаления если очередь пуста
EnableDisableButton();
end;
// перемещение очереди в начало массива
procedure TMainForm.btnReMoveQueTopClick(Sender: TObject);
var
kol : Integer;
begin
if not IsEmpty(que) then
begin
if que.first = 1 then
ShowMessage('Очередь в начале массива')
else
begin
kol := que.first -1;
ReMoveQueueToTop(que);
Memo1.Text := PrintQueue(que);
ShowMessage('Массив очереди смещен влево на ' + IntToStr(kol) + ' элементов');
end;
end;
end;
// при входе в поле ввода изменить цвет фона на желтый
procedure TMainForm.edtMag_NumEnter(Sender: TObject);
begin
if (Sender is TEdit) then
(Sender as TEdit).Color := clYellow
else if (Sender is TMaskEdit) then
(Sender as TMaskEdit).Color := clYellow;
end;
// при выходе из поле ввода вернуть белый цвет фона
procedure TMainForm.edtMag_NumExit(Sender: TObject);
begin
if (Sender is TEdit) then
(Sender as TEdit).Color := clWhite
else if (Sender is TMaskEdit) then
(Sender as TMaskEdit).Color := clWhite;
end;
procedure TMainForm.EnableDisableButton();
begin
// запретить кнопки удаления если очередь пуста
if IsEmpty(que) then
begin
btnDelete.Enabled := False;
btnClearQue.Enabled := False;
btnReMoveQueTop.Enabled := False;
btnSaveFile.Enabled := False;
end
else
begin
btnDelete.Enabled := True;
btnClearQue.Enabled := True;
btnReMoveQueTop.Enabled := True;
btnSaveFile.Enabled := True;
end
end;
procedure TMainForm.mnuCloseClick(Sender: TObject);
begin
Close; // закрываем форму
end;
// о программе
procedure TMainForm.mnuHelpClick(Sender: TObject);
const
CR = #13#10;
begin
MessageDlg('Эта программа демонстрирует основные операции' + CR
+ 'с очередью на массиве.' + CR + CR
+ '1) Вставка в очередь: Заполните поля ввода и нажмите кнопку [Добавить]' + CR
+ '2) Удаление из очереди: Нажмите кнопку [Удалить] или [Очистить]' + CR
+ '3) Смещение очереди в начало массива: Нажмите кнопку [Сместить очередь в начало массива]' + CR
+ '4) Сохранение очереди в файл: Нажмите кнопку [Сохранить в файл]' + CR
+ '5) Загрузка очереди из файла: Нажмите кнопку [Загрузить из файла]' + CR
, mtInformation, [mbOK], 0);
end;
end.
//-------------------------------------------------------------------------------------
unit ArrayQU;
interface
uses
Dialogs, SysUtils, Classes;
const
QUE_SIZE = 20; // максимальное кол-во элементов в очереди
type
// структура Магазин
TMagazine_Rec = record
Mag_Num: Integer; // номер магазина
Mag_Name: string[30]; // наименование магазина
FIO_Dir: string[30]; // ФИО директора магазина
Kol_Sotr: Integer; // количество сотрудников
Dohod: Double; // годовой доход
end;
// структура Очередь
TQueue = record
aMagazine: array[1..QUE_SIZE] of TMagazine_Rec;
first, last: Integer;
end;
procedure InitQueue(var que: TQueue);
procedure EnQueue(var que: TQueue; new_mag: TMagazine_Rec);
function DeQueue(var que: TQueue): TMagazine_Rec;
function IsEmpty(que: TQueue) : Boolean;
function Top(que: TQueue): TMagazine_Rec;
procedure ReMoveQueueToTop(var que: TQueue);
function PrintQueue(que: TQueue): string;
implementation
// инициализация очереди
procedure InitQueue(var que: TQueue);
begin
que.first := 1;
que.last := 0;
end;
// очередь пуста?
function IsEmpty(que: TQueue) : Boolean;
begin
Result := (que.last < que.first);
end;
// добавление элемента в хвост очереди
procedure EnQueue(var que: TQueue; new_mag: TMagazine_Rec);
begin
if que.last >= QUE_SIZE then // очередь заполнена?
begin
raise EInvalidOperation.Create('Очередь заполнена.');
end;
Inc(que.last); // увеличиваем указатель хвоста
que.aMagazine[que.last] := new_mag; // заносим данные
end;
// удаление элемента из головы очереди
function DeQueue(var que: TQueue): TMagazine_Rec;
begin
if IsEmpty(que) then // очередь пуста?
raise EInvalidOperation.Create('Очередь пуста.');
Result := que.aMagazine[que.first]; // помещаем в голову
Inc(que.first); // увеличиваем указатель головы
end;
// вернуть первый элемент очереди
function Top(que: TQueue): TMagazine_Rec;
begin
if IsEmpty(que) then // очередь пуста?
raise EInvalidOperation.Create('Очередь пуста.');
Result := que.aMagazine[que.first]; // возвращаем данные магазина
end;
// смещение очереди в начало массива
procedure ReMoveQueueToTop(var que: TQueue);
var
i, kol_el : Integer;
begin
if not IsEmpty(que) then // если очередь не пуста
if que.first > 1 then // если очередь не в начале массива
begin
kol_el := que.last - que.first + 1;
for i := que.first to que.last do
begin
que.aMagazine[i - que.first + 1] := que.aMagazine[i];
end;
que.first := 1;
que.last := kol_el;
end;
end;
// вывод очереди
function PrintQueue(que: TQueue): string;
const
CR = #13#10;
var
i : Integer;
begin
Result := '';
for i := que.first to que.last do // проход от головы до хвоста
Result := Result
+ '--- №п/п ' + IntToStr(i) + ' --------------------' + CR
+ IntToStr(que.aMagazine[i].Mag_Num) + CR
+ que.aMagazine[i].Mag_Name + CR
+ que.aMagazine[i].FIO_Dir + CR
+ IntToStr(que.aMagazine[i].Kol_Sotr) + CR
+ FloatToStrF(que.aMagazine[i].Dohod, ffFixed, 10, 2) + CR;
Result := Result
+ '--- Конец очереди --------------------------------' + CR;
end;
end.
2) Динамическая реализация очереди
// -----------------------------------------------------------------------------
// 2) Очередь на основе динамического списка
// -----------------------------------------------------------------------------
program LinkedQ;
uses
Forms,
LinkedQF in 'LinkedQF.Pas' {MainForm},
LinkedQC in 'LinkedQC.Pas';
{$R *.RES}
begin
Application.Initialize;
Application.CreateForm(TMainForm, MainForm);
Application.Run;
end.
unit LinkedQF;
interface
uses
Windows, Messages, SysUtils, Graphics, Controls, Forms, Dialogs,
Menus, StdCtrls, Classes, StrUtils,
LinkedQC;
type
TMainForm = class(TForm)
lblMag_Num: TLabel;
lblFIO_Dir: TLabel;
lblMag_Name: TLabel;
lblKol_Sotr: TLabel;
lblDohod: TLabel;
btnInsert: TButton;
Memo1: TMemo;
btnSaveFile: TButton;
btnOpenFile: TButton;
edtMag_Num: TEdit;
edtFIO_Dir: TEdit;
edtMag_Name: TEdit;
edtKol_Sotr: TEdit;
edtDohod: TEdit;
btnDelete: TButton;
btnClearQue: TButton;
OpenDialog1: TOpenDialog;
SaveDialog1: TSaveDialog;
MainMenu1: TMainMenu;
mmFile: TMenuItem;
mnuClose: TMenuItem;
mmHelp: TMenuItem;
mnuHelp: TMenuItem;
procedure mnuCloseClick(Sender: TObject);
procedure mnuHelpClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure btnInsertClick(Sender: TObject);
procedure btnDeleteClick(Sender: TObject);
procedure btnClearQueClick(Sender: TObject);
procedure btnSaveFileClick(Sender: TObject);
procedure edtMag_NumChange(Sender: TObject);
procedure btnOpenFileClick(Sender: TObject);
procedure edtMag_NumEnter(Sender: TObject);
procedure edtMag_NumExit(Sender: TObject);
private
{ Private declarations }
procedure ClearFields();
procedure EnableDisableButton();
public
{ Public declarations }
end;
var
MainForm: TMainForm;
implementation
var
// переменные для работы с очередью
que : TQueue; // очередь
mag : TMagazine; // магазин
FileName_Zap : string;
File_Zap : TextFile;
{$R *.DFM}
procedure TMainForm.FormCreate(Sender: TObject);
begin
InitQueue(que);
end;
// очистка полей
procedure TMainForm.ClearFields();
begin
edtMag_Num.Clear;
edtMag_Name.Clear;
edtFIO_Dir.Clear;
edtKol_Sotr.Clear;
edtDohod.Clear;
// и запрещаем кнопку вставки т.к. поля ввода пустые
btnInsert.Enabled := False;
end;
procedure TMainForm.EnableDisableButton();
begin
// запретить кнопки удаления если очередь пуста
if IsEmpty(que) then
begin
btnDelete.Enabled := False;
btnClearQue.Enabled := False;
btnSaveFile.Enabled := False;
end
else
begin
btnDelete.Enabled := True;
btnClearQue.Enabled := True;
btnSaveFile.Enabled := True;
end
end;
procedure TMainForm.btnInsertClick(Sender: TObject);
begin
// если поля не заполнены - отказать в добавлении записи
if (edtMag_Num.Text = '') then
begin
edtMag_Num.SetFocus;
ShowMessage('Заполните номер магазина');
Exit;
end
else if (edtMag_Name.Text = '') then
begin
edtMag_Name.SetFocus;
ShowMessage('Заполните наименование магазина');
Exit;
end
else if (edtFIO_Dir.Text = '') then
begin
edtFIO_Dir.SetFocus;
ShowMessage('Заполните ФИО директора магазина'); // выдать сообщение
Exit;
end
else if (edtKol_Sotr.Text = '') then
begin
edtKol_Sotr.SetFocus;
ShowMessage('Заполните кол-во сотрудников магазина'); // выдать сообщение
Exit;
end
else if (edtDohod.Text = '') then
begin
edtDohod.SetFocus;
ShowMessage('Заполните год. доход магазина'); // выдать сообщение
Exit;
end;
mag.Mag_Num := StrToInt(edtMag_Num.Text);
mag.Mag_Name := edtMag_Name.Text;
mag.FIO_Dir := edtFIO_Dir.Text;
mag.Kol_Sotr := StrToInt(edtKol_Sotr.Text);
mag.Dohod := StrToFloat(edtDohod.Text);
EnQueue(que, mag);
Memo1.Text := PrintQueue(que);
ClearFields();
// фокус на 1-ое поле
edtMag_Num.SetFocus;
EnableDisableButton();
end;
procedure TMainForm.mnuHelpClick(Sender: TObject);
const
CR = #13#10;
begin
MessageDlg('Эта программа демонстрирует основные операции' + CR
+ 'с очередью на связанном списке.' + CR + CR
+ '1) Вставка в очередь: Заполните поля ввода и нажмите кнопку [Добавить]' + CR
+ '2) Удаление из очереди: Нажмите кнопку [Удалить] или [Очистить]' + CR
+ '3) Сохранение очереди в файл: Нажмите кнопку [Сохранить в файл]' + CR
+ '4) Загрузка очереди из файла: Нажмите кнопку [Загрузить из файла]' + CR
, mtInformation, [mbOK], 0);
end;
procedure TMainForm.mnuCloseClick(Sender: TObject);
begin
Close; // закрываем форму
end;
procedure TMainForm.btnDeleteClick(Sender: TObject);
begin
mag := DeQueue(que);
Memo1.Text := PrintQueue(que);
// заполнить поля удаленной записью
edtMag_Num.Text := IntToStr(mag.Mag_Num);
edtMag_Name.Text := mag.Mag_Name;
edtFIO_Dir.Text := mag.FIO_Dir;
edtKol_Sotr.Text := IntToStr(mag.Kol_Sotr);
edtDohod.Text := FloatToStrF(mag.Dohod, ffFixed, 10, 2);
// фокус на 1-ое поле
edtMag_Num.SetFocus;
// запретить кнопки удаления если очередь пуста
EnableDisableButton();
end;
procedure TMainForm.btnClearQueClick(Sender: TObject);
begin
// очистить очередь
ClearQueue(que);
Memo1.Clear;
// запретить кнопки удаления т.к. очередь пуста
EnableDisableButton();
end;
procedure TMainForm.btnSaveFileClick(Sender: TObject);
var
i : Integer;
tmp_node : PNode;
begin
// кнопка Создать файл (создание нового файла)
SaveDialog1.Title := 'Сохранить в файл'; // Изменение заголовка окна диалога
SaveDialog1.FileName := 'Queue.txt';
if SaveDialog1.Execute then // открытие окна диалога выбора файла
begin
FileName_Zap := SaveDialog1.FileName; // Имя выбранного в диалоге файла
AssignFile(File_Zap, FileName_Zap); // Связывание файловой переменной File_Zap с именем файла
Rewrite(File_Zap); // Создаем файл
if not IsEmpty(que) then
begin
tmp_node := que.first;
repeat
Inc(i);
Writeln(File_Zap, IntToStr(tmp_node^.Magazine.Mag_Num));
Writeln(File_Zap, tmp_node^.Magazine.Mag_Name);
Writeln(File_Zap, tmp_node^.Magazine.FIO_Dir);
Writeln(File_Zap, IntToStr(tmp_node^.Magazine.Kol_Sotr));
Writeln(File_Zap, FloatToStrF(tmp_node^.Magazine.Dohod, ffFixed, 10, 2));
tmp_node := tmp_node.next;
until tmp_node = que.first;
end;
CloseFile(File_Zap); // Закрытие файла
end;
end;
procedure TMainForm.edtMag_NumChange(Sender: TObject);
begin
btnInsert.Enabled := (edtMag_Num.Text <> '');
end;
procedure TMainForm.btnOpenFileClick(Sender: TObject);
var
num_zap : Integer;
s : string;
begin
// кнопка Открыть файл (открытие существующего файла)
if OpenDialog1.Execute then // если в диалоге открытия нажата кнопка ОК
begin
FileName_Zap := OpenDialog1.FileName; // имя выбранного файла
AssignFile(File_Zap, FileName_Zap); // Связывание файловой переменной File_Zap с именем файла
Reset(File_Zap); // Открываем выбранный файл
InitQueue(que); // очистить очередь
Memo1.Clear; // очистить Memo
num_zap := 0; // счетчик записей в файле
// читаем пока не конец файла и кол-во не больше размера очереди
while (not eof(File_Zap)) and (num_zap <= QUE_SIZE) do
begin
num_zap := num_zap + 1; // увеличим счетчик считываемой записи
// Читаем из файла
Readln(File_Zap, s);
mag.Mag_Num := StrToInt(s);
Readln(File_Zap, s);
mag.Mag_Name := s;
Readln(File_Zap, s);
mag.FIO_Dir := s;
Readln(File_Zap, s);
mag.Kol_Sotr := StrToInt(s);
Readln(File_Zap, s);
mag.Dohod := StrToFloat(s);
EnQueue(que, mag);
Memo1.Text := PrintQueue(que);
ClearFields();
// фокус на 1-ое поле
edtMag_Num.SetFocus;
end;
end;
CloseFile(File_Zap); // Закрытие файла
// разблокировать кнопки если очередь не пуста
EnableDisableButton();
end;
procedure TMainForm.edtMag_NumEnter(Sender: TObject);
begin
(Sender as TEdit).Color := clYellow;
end;
procedure TMainForm.edtMag_NumExit(Sender: TObject);
begin
(Sender as TEdit).Color := clWhite;
end;
end.
//-------------------------------------------------------------------------------------
unit LinkedQC;
interface
uses
Dialogs, SysUtils, Classes;
const
QUE_SIZE = 20; // максимальное кол-во элементов в очереди
type
// структура Магазин
TMagazine = Record
Mag_Num: Integer; // номер магазина
Mag_Name: string[30]; // наименование магазина
FIO_Dir: string[30]; // ФИО директора магазина
Kol_Sotr: Integer; // количество сотрудников
Dohod: Double; // годовой доход
end;
// односвязный список
PNode = ^TNode;
TNode = Record
Magazine: TMagazine;
next: PNode;
end;
// структура Очередь
TQueue = record
first, last : PNode;
count : Integer;
end;
procedure InitQueue(var que: TQueue);
procedure ClearQueue(var que: TQueue);
procedure EnQueue(var que: TQueue; new_mag: TMagazine);
function DeQueue(var que: TQueue): TMagazine;
function Top(que: TQueue): TMagazine;
function IsEmpty(que: TQueue): Boolean;
function IsFull(que: TQueue): Boolean;
function PrintQueue(que: TQueue): string;
implementation
...
Подобные документы
Общее понятие и специфика применения очереди в программировании. Способы реализации очереди, их сущностная характеристика. Основные проблемы в использовании списков. Представление очереди в виде массива и двух целочисленных переменных start и end.
презентация [895,9 K], добавлен 14.10.2013Понимание принципа работы очереди. Возможности обращения к первому и последнему элементов очереди. Создание очереди с помощью массива. Рассмотрение примеров использования очереди с приоритетом в программе. Формирование односвязного и двусвязного списков.
контрольная работа [345,6 K], добавлен 26.11.2020Разработка класса "очередь с приоритетами" на языке С++ с использованием объектно-ориентированного проектирования. Построение алгоритмов обработки очереди, методов вставки, удаления, вывода на экран элементов. Анализ вариантов реализации очередей.
курсовая работа [398,6 K], добавлен 28.05.2016Создание стека как линейного списка. Использование аналогичного ссылочного типа для организации очереди. Циклически связанный список. Построение сложных структур в динамической памяти. Бинарные (двоичные) деревья. Экран результата и контрольные расчеты.
лабораторная работа [398,9 K], добавлен 14.06.2009Порядок проектирования программы, демонстрирующей принцип заполнения очереди и стека и принцип удаления элементов из очереди и стека. Определение класса и всех необходимых функций. Программа на языке С, описание возможностей, используемых для алгоритма.
курсовая работа [254,3 K], добавлен 20.05.2013Создание баз хозяйственных договоров, банков и членов временных трудовых коллективов в среде разработки Delphi. Логическая структура линейного двусвязного списка. Способ упорядочения и алгоритм сортировки списка. Руководство пользования программой.
курсовая работа [749,4 K], добавлен 14.02.2016Моделирование работы компьютерного зала в течении 60 ч. Определение загрузки устройства подготовки данных (УПД), ЭВМ и вероятности отказа в обслуживании вследствие переполнения очереди. Определение соотношения желающих работать на ЭВМ и на УПД в очереди.
контрольная работа [275,7 K], добавлен 05.07.2014Средства создания динамических структур данных. Формат описания ссылочного типа. Структура памяти во время выполнения программы. Линейные списки, стек, очередь. Организация списков в динамической памяти. Пример создания списка в обратном порядке.
лабораторная работа [788,2 K], добавлен 14.06.2009Теоретическое описание линейного списка с алгоритмами реализации основных операций. Понятия, механизмы объектно-ориентированного программирования. Возможности проектируемого контейнера пользователей, его реализация на основе линейного списка с заголовком.
курсовая работа [475,2 K], добавлен 26.02.2015Очередь в циклическом массиве. Извлечение элемента из очереди. Анализ сложности алгоритма. Класс входных данных, для которых применим алгоритм или структура. Выбор средств разработки. Определение отображаемых элементов, проектирование интерфейса.
курсовая работа [299,9 K], добавлен 07.06.2014Основные понятия объектно-ориентированного программирования, особенности описания функций и классов. Разработка программы для работы с универсальной очередью установленного типа, добавления и удаления ее элементов и вывода содержимого очереди на экран.
курсовая работа [187,2 K], добавлен 27.08.2012Блокировка файла для защиты доступа к нему со стороны других процессов в многозадачной среде операционной системы. Управление периферийными устройствами, процессами (заданиями, задачами). Планирование процессов, понятие очереди. Общий буфер данных.
презентация [45,2 K], добавлен 23.10.2013Составление схемы концептуальной модели данных. Разработка структуры реляционной базы данных и интерфейса пользователя. Особенности главных этапов проектирования базы данных. Способы реализации запросов и отчетов. Специфика руководства пользователя.
курсовая работа [186,9 K], добавлен 18.12.2010Разработка имитационной модели, которая может быть использована для анализа ситуации в банке с помощью следующих статистических характеристик: время ожидания клиентов в очереди и пребывания в системе, загрузка кассира, число клиентов в очереди, на выезд.
курсовая работа [594,3 K], добавлен 28.10.2013- Обзор Windows Vista. Разработка консольного приложения, реализующего кольцевую очередь(20 элементов)
Обзор и комплексный анализ операционной системы Windows Vista, оценка ее преимуществ и недостатков. Разработка программы, которая реализует алгоритм очереди на 20 элементов. Построение блок-схемы и листинг алгоритма, контрольный пример его работы.
курсовая работа [4,2 M], добавлен 20.11.2013 Структурная схема процесса функционирования вычислительного центра. Моделирование процесса обслуживания ста пользователей. Оценка числа пользователей в очереди, коэффициента загрузки ЭВМ, вероятности отказа по причине отсутствия свободных мест в очереди.
курсовая работа [54,9 K], добавлен 25.06.2011Расположение элементов списка в памяти. Информация о полях структуры TMember. Логическая структура двусвязного кольцевого списка. Логические схемы наиболее важных операций со списками. Алгоритмы обработки основных структур. Руководство пользователя.
курсовая работа [2,3 M], добавлен 27.08.2012Представление (построение, создание) списка данных в виде линейного однонаправленного списка. Формирование массива данных. Вывод данных на экран. Алгоритм удаления, перемещения данных. Сортировка методом вставки. Алгоритм загрузки данных из файла.
курсовая работа [2,1 M], добавлен 16.05.2015Способы ограждения пользователей от деталей фактического устройства данных. Список описателей переменных, указателей или массивов. Статические или динамические структуры данных. Доступ к различным элементам данных. Добавление и удаление элементов.
презентация [57,8 K], добавлен 14.10.2013Алгоритмы задач об упаковке в контейнеры: "Следующий подходящий" (NF), "Первый подходящий" (FF), "Наилучший подходящий" (BF), On-line, с ограниченным доступом к контейнерам, первый подходящий с упорядочиванием (FFD). Релаксация линейного программирования.
реферат [673,7 K], добавлен 22.05.2014
