МИНОБРНАУКИ РОССИИ

ФЕДЕРАЛЬНОЕ ГОСУДАРСТВЕННОЕ БЮДЖЕТНОЕ

ОБРАЗОВАТЕЛЬНОЕ УЧРЕЖДЕНИЕ ВЫСШЕГО ОБРАЗОВАНИЯ
«ВОРОНЕЖСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ»
(ФГБОУ ВО «ВГУ»)

Факультет прикладной математики, информатики и механики

Кафедра программного обеспечения и администрирования информационных
систем

Очереди. Сплошное представление

Курсовая работа
Направление 09.03.03. Прикладная информатика
Профиль Прикладная информатика в юриспруденции

Зав. Кафедрой ____________д. ф.-м. н., проф. M. А. Артёмов

Обучающийся ____________2 курс 101 группа С. Ю. Степин
Руководитель _____________ Т.В. Курченкова
Воронеж 2023
 2

Аннотация
Работа позволяет продемонстрировать особенности очереди,
использующей сплошное представление, на примере языка C#.
Цель – рассмотреть возможности, предоставляемые очередью
в заданной реализации, и создать программу, обеспечивающую выполнение
основных операций над очередью.
Тема имеет важное учебное значение и позволяет изучить основные
принципы такой структуры данных, как очередь, на примере выбранного
языка C#.
 3

Содержание
Введение....................................................................................................................................................4
1. Постановка задачи.............................................................................................................................6
2. Анализ задачи....................................................................................................................................7
2.1. Общий анализ задачи................................................................................................................7
2.2. Структура данных.......................................................................................................................7
2.3. Структура программы................................................................................................................7
2.3.1. Структура модуля для работы с очередью..........................................................................7
2.3.2. Структура модуля вспомогательных функций.....................................................................8
2.3.3. Структура главной программы..............................................................................................8
3. Средства реализации........................................................................................................................9
4. Требования к программному и аппаратному обеспечению........................................................10
5. Интерфейс пользователя................................................................................................................11
6. Реализация.......................................................................................................................................13
6.1. Структура данных.....................................................................................................................13
6.2. Основные функциональные блоки приложения...................................................................16
6.3. Взаимодействие функциональных блоков............................................................................17
6.4. Описание модулей...................................................................................................................17
6.4.1. Структура модуля для работы с очередью........................................................................17
6.4.2. Структура модуля вспомогательных функций...................................................................18
6.4.3. Структура главной программы............................................................................................19
7. План тестирования..........................................................................................................................20
7.1. Тест 1. «Ввод данных в очереди»...........................................................................................20
7.2. Тест 2. «Решение задачи».......................................................................................................20
7.3. Тест 3. «Очистка».....................................................................................................................20
Заключение..............................................................................................................................................21
Список литературы..................................................................................................................................22
Приложение 1. Листинг файла UQueue.cs.............................................................................................23
Приложение 2. Листинг файла UQueueHelper.cs...................................................................................25
 4

Введение
Курсовая работа посвящена изучению очереди, использующей
сплошное представление, на языке C#.
Очередь – это упорядоченный набор элементов, которые могут
удаляться с одного ее конца (называемого началом очереди) и помещаться
в другой конец этого набора (называемого концом очереди). Это структура
данных, которая организована по тем же принципам, что и обычная очередь
из повседневной жизни и отражает специфику моделируемых объектов.
Поэтому такие структуры используются для моделирования реальных
очередей с целью определения их характеристик [3,4].
В очереди доступны две позиции – ее начало (из этой позиции элемент
выбирается для его обслуживания, при этом он исключается из очереди)
и конец (в эту позицию помещается элемент, который заносится в очередь).
Дисциплина обслуживания очереди функционирует согласно правилу
FIFO: First In – First Out (первым пришел – первым ушел) [1].
Сплошная реализация очереди представляет собой организацию
очереди на основе массива. Преимуществом данной реализации является
незначительная экономия памяти, также она проще в разработке. Главным
недостатком служит то, что максимальное количество элементов в очереди
ограничено размером массива [3].
Сплошное представление очереди использует две целочисленные
переменные, содержащие индексы начала очереди и количества элементов
в ней. Обеспечивается доступ к элементам очереди в начале и добавлении
в конец, доступ к произвольному элементу очереди в данной реализации не
предусмотрен [3].
Цель работы – реализовать программу, которая будет обеспечивать
выполнение основных операций над очередью, использующей сплошное
представление.
 5

Для достижения цели необходимо решить следующие задачи:

 анализ структур данных для реализации очереди;
 выбор средств реализации;
 разработка структуры программы;
 реализация программы, решающей поставленную задачу.
Тема работы имеет важное учебное значение. Она позволяет изучить
основные принципы типа данных очередь и использовать полученные знания
при решении практических задач.
 6

1. Постановка задачи
Написать программу для решения следующей задачи:
«Даны две очереди из чисел. Разместить в одной очереди положительные
элементы, а в другой – отрицательные, не используя дополнительных
структур данных, кроме набора переменных» [2].
В программе должны быть реализованы следующие функции:
инициализация, проверка на пустоту, проверка на полноту, добавление
элемента, извлечение элемента.
 7

2. Анализ задачи
2.1. Общий анализ задачи

Для решения поставленной задачи необходимо реализовать программу,

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

2.2. Структура данных

Для работы с очередью, использующей сплошное представление,

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

2.3. Структура программы

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

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

2.3.1. Структура модуля для работы с очередью

В данный модуль входят следующие функции и процедуры, которые

осуществляют работу с очередью [4]:
1. Процедура инициализации очереди.
2. Функция проверки очереди на пустоту. Возвращает значение true,
если очередь пуста, false – в противном случае.
 8

3. Функция проверки очереди на полноту. Возвращает значение true,

если очередь полна, false – в противном случае.
4. Функция, которая пытается поместить элемент в очередь.
Возвращает значение true, если удалось поместить элемент
в очередь, false – в противном случае.
5. Процедура добавления элемента в очередь. В случае неудачи
генерируется исключительная ситуация.
6. Функция, которая пытается достать элемент из очереди.
Возвращает значение true, если попытка удалась, false –
в противном случае.
7. Функция, которая извлекает элемент из очереди. В случае неудачи
генерируется исключительная ситуация.

2.3.2. Структура модуля вспомогательных функций

Данный модуль связан с модулем для работы с очередью, в него входят

следующие процедуры и функции:
1. Процедура очистки очереди.
2. Функция конвертирования информации из очереди в строку.
3. Функция конвертирования данных из строки в очередь. Если
конвертация прошла удачно, то функция возвращает результат
true, false – в противном случае.

2.3.3. Структура главной программы

В модуле главной программы расположена форма, на которой

расположены визуальные компоненты. Они предоставляют пользователю
следующие возможности:
1. Ввод значений в очереди.
2. Решение задачи, при нажатии на кнопку «Запуск».
3. Очистка очередей, при нажатии на кнопку «Очистка».
4. Закрытие формы, при нажатии на кнопку «Выход».
 9

3. Средства реализации
В качестве языка программирования был выбран язык C#.
Возможности данного языка предоставляют все необходимые инструменты
для реализации поставленных в работе целей и задач. При реализации
проекта использовалась среда разработки Visual Studio 2019.
 10

4. Требования к программному и аппаратному обеспечению

Приложение предназначено для использования на компьютерах,
с установленной операционной системой Windows 7, Windows 8, Windows 10.
Минимальные системные требования приложения обусловлены
требованиями операционной системы.
 11

5. Интерфейс пользователя

В начале работы пользователю доступна форма, представленная

на рис. 5.1.

Рис. 5.1. Форма при запуске программы

При запуске программы очереди заполняются исходными данными,

на основе которых будет выполняться решение поставленной задачи. После
описания двух очередей форма будет выглядеть как на рис. 5.2.
 12

Рис. 5.2. Форма после заполнения очередей

При попытке запуска пустых очередей, выводится сообщение,

изображенное на рис. 5.4.

Рис. 5.4. Сообщение о пустоте очередей

Кнопка «Очистка» очищает все компоненты и возвращает форму
к первоначальному виду (рис. 5.1.).
При попытке очистки пустых очередей, выводится сообщение,
изображенное на рис. 5.4.
Кнопка «Выход» приводит к закрытию формы.
 13

6. Реализация
6.1. Структура данных

Организации очереди:

public class Program {

public struct TQueue { /*Очередь из элементов*/

public int[] Elems; /*Массив из элементов*/

public int Head; /*Начало очереди*/

public int Count; /*Количество элементов в очереди*/

}

6.2. Основные функциональные блоки приложения

Приложение состоит из трёх блоков:

1. Главная программа, в которой расположена форма, из которой
происходит вызов необходимых элементов класса для работы с очередью.
2. Класс для работы с очередью UQueue содержит методы,
предназначенные для работы непосредственно с очередью, использующей
сплошное представление, например, добавление и извлечение элемента из
очереди.
3. Модуль вспомогательных функций UQueueHelper реализует
дополнительные методы для работы с очередью, например, функция
конвертирования данных из строки в очередь.

6.3. Взаимодействие функциональных блоков

Проект состоит из двух модулей и главной программы, в каждом из

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

Главная программа

Класс вспомогательных
 14
Рис 6.1. Схема взаимодействия функциональных блоков

6.4. Описание модулей

6.4.1. Структура модуля для работы с очередью

1. public static void Init(ref TQueue Q);

Процедура инициализации очереди. В качестве параметра передаётся
Q – инициализируемая очередь.
2. public static bool IsEmpty(ref TQueue Q);
Функция проверки очереди Q на пустоту. Возвращает значение true,
если очередь пуста, false – в противном случае.
3. public static bool IsFull(ref TQueue Q);
Функция проверки очереди Q на полноту. Возвращает значение true,
если очередь полна, false – в противном случае.
4. public static bool TryPush(ref TQueue Q, int el);
Функция, которая пытается поместить элемент el в очередь Q.
Возвращает значение true, если удалось элемент поместить в очередь, false –
в противном случае.
5. public static void Push(ref TQueue Q, int el);
Процедура добавления элемента el в очередь Q. Если в очереди
достигнуто максимальное количество элементов, и добавить новый элемент
нельзя, выводится сообщение об этом.
6. public static bool TryPop(ref TQueue Q, out int el);
Функция, которая пытается достать элемент el из очереди Q.
Возвращает значение true, если попытка удалась, false – в противном случае.
7. public static int Pop(ref TQueue Q);
Функция, которая извлекает элемент el из очереди Q. При попытке
достать элемент из пустой очереди выводится сообщение об этом.

6.4.2. Структура модуля вспомогательных функций

1. public static void ClearQueue(ref TQueue Q);

Процедура очистки очереди. В качестве параметра передаётся
 15

очередь Q.
2. public static string QueueToStr(ref TQueue Q);
Функция конвертирования информации из очереди Q
в результирующую строку с очисткой очереди.
3. public static bool TryStrToQueue(string str, ref TQueue Q);
Функция, которая пытается конвертировать данные из строки str
в очередь Q. Если конвертация прошла удачно, то функция возвращает
результат true, false – в противном случае.

6.4.3. Структура главной программы

1. private void BtnStartClick(object sender, EventArgs e);

Процедура реализации решения заданной задачи. Происходит загрузка
данных из компонентов ввода EditInput1, EditInput2 типа TEdit в очереди
FQueue1, FQueue1 типа TQueue, размещение элементов очередей FQueue1,
FQueue1 в результирующие очереди FQueueR1, FQueueR2 типа TQueue
в зависимости от знака элемента, и вывод содержимого результирующих
очередей в компоненты вывода EditOutput1, EditOutput1 типа TEdit.
2. public void BtnClearClick(object sender, EventArgs e);
Процедура очищает компоненты EditInput1, EditInput2 типа TEdit.
3. public void BtnExistClick(object sender, EventArgs e);
Процедура закрытия формы Form1 типа TForm1.
4. public void EditInput1Change(object sender, EventArgs e);
Процедура очистки компонентов вывода EditOutput1, EditOutput2 типа
TEdit при изменении поля ввода EditInput1 типа TEdit.
 16

7. План тестирования
Для проверки корректности работы данной программы необходимо
провести определенный набор тестов, каждый из которых будет проверять
работоспособность определенной операции, производимой с очередью.
Тестирование данного приложения заключается в проверке
работоспособности программы для различных данных, которые может ввести
пользователь.

7.1. Тест 1. «Ввод данных в очереди»

Цель теста: проверка корректности работы программы в случае ввода

не числовых символов, или дробных чисел в компоненты ввода типа TEdit.
Описание теста: вводятся не числовые символы в первую очередь.
Результат: пользователю выводится сообщение «Ошибка ввода данных
в первую очередь!».

7.2. Тест 2. «Решение задачи»

Цель теста: проверка корректности работы программы при решении

заданной задачи.
Описание теста и результат: при нажатии кнопки «Запуск»
в соответствующем поле вывода будут представлены результирующие
очереди.

7.3. Тест 3. «Очистка»

Цель теста: проверка корректности работы при очистке компонентов

типа TEdit.
Описание теста и результат: при попытке очистки пустых очередей,
выводится соответствующее сообщение «Очереди пусты!».
 17

Заключение
Курсовая работа позволила изучить основные принципы и идеи работы
с очередями, использующими сплошное представление, на примере языка
C#, а также реализовать программу, которая обеспечивает выполнение
основных операций над очередью.
В результате решения поставленной задачи была создана
и протестирована программа, позволяющая выполнять следующие операции
с очередями:
1. Инициализация очереди.
2. Проверка очереди на пустоту.
3. Проверка очереди на полноту.
4. Добавление элемента.
5. Извлечение элемента.
При выполнении курсовой работы были решены следующие задачи:
 проанализированы структуры данных для реализации очереди;
 выбраны средства реализации;
 разработана структура программы;
 реализована программа, решающая поставленную задачу.
 18

Список литературы
1. Вирт Н. Алгоритмы и структуры данных / Н. Вирт ; пер. с англ.
Д. Б. Подшиваловой. – 2-е изд., испр. – Санкт-Петербург : Нев. диалект,
2001. – 352 с.
2. Воронина И. E. Практикум по курсу «Структуры и алгоритмы
компьютерной обработки данных» / И. E. Воронина, Н. В. Огаркова –
Воронеж, 2009. – 35 c.
3. Грогоно П. Программирование на языке С# / П. Грогоно; пер. с англ.
Л. Е. Карпова; под ред. Д. Б. Подшивалова – Москва : Мир, 1982. – 384 с.
4. Программирование алгоритмов обработки данных / О. Ф. Ускова,
И. E. Воронина, Н. В. Огаркова, М. В. Бакланов – СПб.: БХВ-Петербург,
2003. – 192 c.
5. С# и .Net Core. 3-е издание / Прайс
6. С# для начинающих/ Пахомов Б. И. — СПб.: БХВ-Петербург, 2014. — 432
с. – 105 c.
 19

Приложение 1. Листинг файла UQueue.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using System;

namespace UQueue
{

public struct TQueue

{
public int[] Elems;
public int Head;
public int Count;
}

public static class Queue

{
private const int V = 100;

public static void Init(ref TQueue Q)

{
Q.Head = 0;
Q.Count = 0;
int MaxN = V;
Q.Elems = new int[MaxN];
}

public static bool IsEmpty(ref TQueue Q)

{
return Q.Count == 0;
}

public static bool IsFull(ref TQueue Q)

{
int MaxN = V;
return Q.Count == MaxN;
}

public static bool TryPush(ref TQueue Q, int el)

{
int MaxN = V;
bool Result = Q.Count < MaxN;
if (Result)
{
int tail = (Q.Head + Q.Count) % MaxN;
Q.Elems[tail] = el;
Q.Count++;
}
return Result;
}

public static void Push(ref TQueue Q, int el)

{
if (!TryPush(ref Q, el))
throw new Exception("Переполнение очереди");
}
 20
public static bool TryPop(ref TQueue Q, out int el)
{
bool Result = Q.Count > 0;
el = 0;
if (Result)
{
el = Q.Elems[Q.Head];
int MaxN = V;
Q.Head = (Q.Head + 1) % MaxN;
Q.Count--;
}
return Result;
}

public static int Pop(ref TQueue Q)

{
int el = 0;
if (!TryPop(ref Q, out el))
throw new Exception("Попытка извлечь элемент из пустой
очереди");
return el;
}
}
}
 21

Приложение 2. Листинг файла UQueueHelper.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using UQueue;

namespace UQueueHelper
{
public static class QueueHelper
{
public static void ClearQueue(ref TQueue Q)
{
int el;
while (TryPop(ref Q, out el)) ;
}

private static bool TryPop(ref TQueue q, out int el)

{
throw new NotImplementedException();
}

public static string QueueToStr(ref TQueue Q)

{
string Result = "";
while (!IsEmpty(ref Q))
Result += Pop(ref Q).ToString() + " ";
return Result.Trim();
}

private static object Pop(ref TQueue q)

{
throw new NotImplementedException();
}

private static bool IsEmpty(ref TQueue q)

{
throw new NotImplementedException();
}

public static string NextWord(string str, ref int i)

{
int len = str.Length;
while (i <= len && str[i] == ' ')
i++;
string Result = "";
while (i <= len && str[i] != ' ')
{
Result += str[i];
i++;
}
return Result;
}

public static bool TryStrToQueue(string str, ref TQueue Q)

{
Init(ref Q);
str = str.Trim();
int len = str.Length;
 22
int i = 0;
bool Result = true;
while (i < len && Result)
{
string wrd = NextWord(str, ref i);
int x;
if (!int.TryParse(wrd, out x))
Result = false;
else
Push(ref Q, x);
}
if (!Result)
ClearQueue(ref Q);
return Result;
}

private static void Init(ref TQueue q)

{
throw new NotImplementedException();
}

private static void Push(ref TQueue q, int x)

{
throw new NotImplementedException();
}
}
}