Динамическая структура данных очередь

Содержание:

Я - репетитор, готовый помочь в реализации структуры данных очередь

Здравствуйте! Меня зовут Александр Георгиевич. Я - профессиональный рейтинговый репетитор по информатике, математике, алгоритмам, базам данных и программированию.

Одной из моих генеральный компетенций является исследование различных популярных динамических структур данных. Уже на протяжении 10 лет я помогаю всем желающим разобраться с такой структурой данных, как очередь. Программирую структуру данных очередь на одном из следующих языков программирования: Pascal, Delphi, C, C++, C#, Basic, VBA.

Очень часто ко мне обращаются студенты из технических вузов РФ и повествуют о том, что у них в некоторых лабораторных требуется провести реализацию структуры данных очередь. Вы должны понимать, что подобная реализация не может стоить очень дешево! После ознакомления с постановкой задачи, я начинаю задавать клиенту уточняющие вопросы. Затем называю конечную стоимость вашего проекта. Мои цены адекватные, поэтому клиент в 99% незамедлительно соглашается.

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

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

Что такое структура данных очередь

Структура данных очередь - частный случай линейного односвязного списка (ЛОС), для которого определены две фундаментальные операции:

  1. Добавление элемента в конец очереди.

  2. Удаление элемента из начала очереди.

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

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

Указатель на начало очереди

Для корректной обработки структуры данных очередь вводят понятие - указатель на начало очереди. Как правило, именуется в программе подобный указатель словом begQ (в переводе с английского означает begin queue - начало очереди). Данный указатель обязан указывать или ссылаться только на самый первый элемент очереди, иначе очередь будет находиться в несогласованном состоянии.

В программе на языке Pascal декларация указателя на первый элемент очереди выглядит примерно так:

  1. var
  2. {указатель на начало очереди, по сути, указатель на первый элемент очереди}
  3.     begQ : Tptr;

Вы должны очень хорошо понимать, что собою представляет тип данных Tptr.

Примечание: зачастую в дидактической литературе можно встретить упоминание об указателе на конец очереди endQ (end queue - конец очереди). То есть иногда обработка очереди строится с применением двух указателей: begQ и endQ. Во всех представленных ниже программах я буду оперировать исключительно одним указателем - указателем на начало очереди, то есть только begQ.

Организация взаимосвязей в связанных динамических данных

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

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

Рассмотрим объявление динамической структуры данных на языке программирования Pascal 7.0.:

  1. type
  2. {указательный тип данных на элемент очереди}
  3.     Tptr = ^Telem;
  4. {запись, состоящая из двух полей, описывающая элемент очереди}
  5.     Telem = record
  6. {информационное поле элемента - хранит символьные значения}
  7.         inf  : char;
  8. {указательное поле на следующий элемент очереди}
  9.         link : Tptr;
  10. {конец описания записи}
  11.     end;

ВАЖНО!
Правило последовательности описаний в Pascal требует, чтобы каждый идентификатор был описан, прежде чем он будет использоваться для других объявлений. Если посмотреть на декларацию, представленную выше, то очевидно, что идентификатор Tptr имеет указательный тип данных Telem, но ведь Telem еще не объявлен. Однако ошибки не возникает, так как для описания типов элементов динамических структур данных сделано исключение.

Вспомогательные инструменты для проведения операций над очередью

Абсолютно во всех операциях, производимых над структурой данных очередь, требуется вспомогательный указатель, помимо указателя begQ, ссылающего на первый элемент очереди. Во всех программах и фрагментах программного кода, представленных ниже, будем обозначать вспомогательный указатель идентификатором p. Почему "p"? Потому что с английского слово pointer переводится на русский как указатель.

Что же такое "NIL"

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

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

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

Добавление новых элементов в очередь связано с динамическим выделением памяти. В языке программирования Pascal для распределения динамической памяти употребляют процедуру new.

В самом широком смысле выделение памяти и инициализация полей производится так:

  1. {выделям память под добавляемый элемент}
  2.     new(add);
  3. {линковочное поле добавляемого элемента устанавливаем в NIL}
  4.     add^.link := NIL;
  5. {диалог пользователю о предстоящем вводе символьного значения}
  6.     write('Введите значение добавляемого элемента: ');
  7. {считываем информацию от пользователя с клавиатуры}
  8.     readln(add^.inf);

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

Добавление элемента в очередь

Необходимо понимать, что существует две разновидности добавления элемента в структуру данных очередь:

  1. Добавление элемента в пустую, то есть не содержащую ни одного элемента очередь.

  2. Добавление элемента в непустую, то есть содержащую определенное количество элементов очередь.

Итак, сначала разберем добавление элемента в пустую очередь

Исходное состояние пустой очереди. Указатель begQ ссылается в NIL.
add - указатель на добавляемый элемент. Линковочное поле добавляемого элемента ссылается в NIL - правило хорошего тона.

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

В результате проведения данной операции очередь находится в согласованном состоянии.

Разберем добавление элемента в непустую очередь

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

add - указатель на добавляемый элемент. Линковочное поле добавляемого элемента ссылается в NIL - правило хорошего тона.

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

Устанавливаем вспомогательный указатель p на первый элемент очереди.

Циклически передвигаем указатель p на последний элемент очереди.

Например, в языке программирования Pascal для передвижения указателя p можно использовать цикл с предусловием или цикл While-Do.

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

Как видно из представленной схемы, операция добавления элемента в конец очереди выполняется элементарно. Необходимо указатель последнего элемента переставить на добавляемый элемент. В итоге очередь находится в согласованном состоянии, так как последний элемент ссылается в NIL, а begQ указывает на первый элемент.

Вывод: операция добавления элемента в очередь успешно проведена.

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

Удаление элемента из очереди

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

Разберем удаление элемента из непустой очереди

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

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

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

То есть фактически обе указательных переменных p и begQ ссылаются на один и тот же элемент - первый элемент структуры данных очередь.

Вторым действием переводим указатель на начало очереди begQ на следующий, по факту - второй элемент очереди.

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

Полностью "отвязываем" удаляемый элемент из очереди, чтобы не осталось ни одной связи с другими элементами. Для этого линковочное поле первого элемента устанавливаем в NIL.

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

Производим собственно удаление первого элемента из очереди. Удаление происходит абсолютно безболезненно, не разрушает внутренние связи очереди и после операции удаления очередь находится в согласованном состоянии: begQ - ссылается на первый элемент, а линковочное поле последнего элемента указывает в NIL.

Для удаления ранее выделенной динамической памяти в языке программирования Pascal используется процедура Dispose, а в языке программирования С - free, в языке С++ - delete.

Конечное состояние очереди после удаления первого элемента.

Вывод: операция удаления элемента из очереди успешно проведена.

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

Схема печати всех элементов очереди

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

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

Предположим, что начальная очередь содержит три элемента. Для визуализации значения информационных полей элементов очереди необходим дополнительный указатель. Введем идентификатор p.

Справа представлен полный процессинг всех итераций по печати элементов очереди на экран пользователя.

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

Как видно из представленной схемы, как только вспомогательный указатель p достигнет NIL, операция вывода будет официально завершена.

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

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

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

Как видно из представленной схемы рекурсивной печати элементов для обхода структуры данных очередь, требуется вспомогательный указатель. Им является идентификатор pp.

На схеме показаны вложенные копии вызова рекурсивной процедуры, причем в каждой версии процедуры существует "свой" указатель pp, указывающий на соответствующий элемент очереди.

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

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

Подобный вариант рекурсии имеет название рекурсия на возврате (для справки: существует также вариация рекурсии на спуске и обобщенный или смешанный вариант рекурсии).

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

Реализация динамической очереди на языке программирования Turbo Pascal

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

Программа реализует следующие операции над структурой данных очередь:

  • Добавление элемента в конец очереди.

  • Удаление элемента из начала очереди.

  • Печать элементов очереди на дисплее пользователя (от начала к концу).

  • Печать элементов очереди на дисплее пользователя от конца к началу (рекурсивно).

  • Получение общего количества элементов в очереди.

Скачать программу реализации динамической очереди на языке программирования Pascal

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

  1. {заголовок программы}
  2. program QUEUE;
  3. {раздел подключения модулей}
  4. uses
  5. {подключаем модуль crt - console run time, чтобы можно было использовать
  6.  подпрограммы для работы с консолью}
  7.     crt;
  8. {раздел объявления пользовательских типов данных}
  9. type
  10. {указательный тип данных на элемент очереди}
  11.     Tptr = ^Telem;
  12. {запись, состоящая из двух полей, описывающая элемент очереди}
  13.     Telem = record
  14. {информационное поле элемента - хранит символьные значения}
  15.         inf  : char;
  16. {указательное поле на следующий элемент очереди}
  17.         link : Tptr;
  18. {конец описания записи}
  19.     end;
  20. {раздел декларации глобальных переменных}
  21. var
  22. {указатель на начало очереди, по сути, указатель на первый элемент очереди}
  23.     begQ : Tptr;
  24. {---------------------------------------------------------------------------}
  25. {Процедура: добавление элемента в конец очереди}
  26. {---------------------------------------------------------------------------}
  27. procedure addElem;
  28. var
  29. {указатель на добавляемый элемент}
  30.     add : Tptr;
  31. {вспомогательный указатель, помогающий произвести операцию добавления}
  32.     p   : Tptr;
  33. {начало тела процедуры}
  34. begin
  35. {выделям память под добавляемый элемент}
  36.     new(add);
  37. {линковочное поле добавляемого элемента устанавливаем в NIL}
  38.     add^.link := NIL;
  39. {диалог пользователю о предстоящем вводе символьного значения}
  40.     write('Введите значение добавляемого элемента: ');
  41. {считываем информацию от пользователя с клавиатуры}
  42.     readln(add^.inf);
  43. {если в очереди нет ни одного элемента, то}
  44.     if(begQ = NIL) then
  45. {устанавливаем указатель начало очереди begQ на добавляемый элемент}
  46.         begQ := add
  47. {иначе в очереди имеется хотя бы один элемент}
  48.     else
  49.     begin
  50. {вспомгательный указатель позиционируется на первый элемент очереди}
  51.         p := begQ;
  52. {цель указателя р добраться до последнего элемента, но поскольку количество
  53.  элементов неизвестно, то приходится использовать цикл с предусловием. Цикл
  54.  продолжается до тех пор, пока указатель р не будет ссылаться на последний
  55.  элемент текущей очереди}
  56.         while(p^.link <> NIL) do
  57. {переходим на следующий элемент очереди}
  58.             p := p^.link;
  59. {устанавливаем связь между последним элементом очереди и добавляемым
  60.  элементом, то есть, новый элемент оказался в самом конце очереди}
  61.         p^.link := add;
  62.     end;
  63. {конец тела процедуры}
  64. end;
  65. {---------------------------------------------------------------------------}
  66. {Процедура: удаление элемента из начала очереди}
  67. {---------------------------------------------------------------------------}
  68. procedure delElem;
  69. var
  70. {вспомогательный указатель, помогающий произвести операцию удаления}
  71.     p : Tptr;
  72. {начало тела процедуры}
  73. begin
  74. {устанавливаем вспомогательный указатель на первый элемент очереди}
  75.     p := begQ;
  76. {перемещаем указатель начала очереди begQ на следующий элемент (второй)}
  77.     begQ := begQ^.link;
  78. {полностью "отвязываем" удаляемый элемент из очереди, чтобы он не имел
  79.  абсолютно никаких связей с остальными элементами очереди. Данная "отвязка"
  80.  не является обязательной, так как после удаления все связи будут
  81.  автоматически уничтожены}
  82.     p^.link := NIL;
  83. {удаляем первый элемент из очереди}
  84.     dispose(p);
  85. {конец тела процедуры}
  86. end;
  87. {---------------------------------------------------------------------------}
  88. {Процедура: печать элементов очереди от начала к концу}
  89. {---------------------------------------------------------------------------}
  90. procedure printQ;
  91. var
  92. {вспомогательный указатель, помогающий произвести печать элементов очереди}
  93.     p : Tptr;
  94. {начало тела процедуры}
  95. begin
  96. {позиционируем вспомогательный указатель на первый элемент очереди}
  97.     p := begQ;
  98. {чтобы распечатать информацию всех элементов очереди, необходимо посетить
  99.  все эти элементы, то есть, надо циклически просмотреть каждый элемент. Цикл
  100.  будет продолжаться до тех пор, пока указатель р не выйдет в NIL}
  101.     while(p <> NIL) do
  102.     begin
  103. {выпечатываем символьное значение текущего элемента}
  104.         write(p^.inf:3);
  105. {указатель р переходит к следующему элементу}
  106.         p := p^.link;
  107.     end;
  108. {конец тела процедуры}
  109. end;
  110. {---------------------------------------------------------------------------}
  111. {Рекурсивная процедура: печать всех элементов очереди от конца к началу.
  112.  Форма выполнения рекурсии - на возврате, т е действия, выполняются после
  113.  рекурсивного вызова}
  114. {---------------------------------------------------------------------------}
  115. procedure recPrintQ(pp : Tptr);
  116. begin
  117. {как известно, любая рекурсия не может выполняться вечно, следовательно,
  118.  должен быть случай (его называют элементарным случаем), когда рекурсия
  119.  завершает свое выполнение. В данном случае, рекурсивный вызов завершается,
  120.  когда указатель-параметр оказывается в NIL, то есть за последним элементом
  121.  очереди. То есть, если указатель ссылается на элемент, то}
  122.     if(pp <> NIL) then
  123.     begin
  124. {происходит рекурсивный вызов процедуры, причем в качестве параметра,
  125.  передается указатель на следующий элемент}
  126.         recPrintQ(pp^.link);
  127. {выпечатываем на экран пользователя значение текущего элемента}
  128.         write(pp^.inf:3);
  129.     end;
  130. {конец тела процедуры}
  131. end;
  132. {---------------------------------------------------------------------------}
  133. {Функция: вывод меню программы}
  134. {---------------------------------------------------------------------------}
  135. function mainMenu : integer;
  136. var
  137. {отвечает за пункт меню выбранный пользователем}
  138.     sel : integer;
  139. {начало тела функции}
  140. begin
  141. {в цикле с постусловием визуализируем пункты меню программы}
  142.     repeat
  143.         clrscr;
  144.         writeln('1 - ДОБАВИТЬ ЭЛЕМЕНТ В ОЧЕРЕДЬ');
  145.         writeln('2 - УДАЛИТЬ ЭЛЕМЕНТ ИЗ ОЧЕРЕДИ');
  146.         writeln('3 - ПЕЧАТЬ ЭЛЕМЕНТОВ ОЧЕРЕДИ ОТ НАЧАЛА К КОНЦУ');
  147.         writeln('4 - РЕКУРСИВНАЯ ПЕЧАТЬ ЭЛЕМЕНТОВ ОЧЕРЕДИ ОТ КОНЦА К НАЧАЛУ');
  148.         writeln('5 - ПОЛУЧИТЬ КОЛИЧЕСТВО ЭЛЕМЕНТОВ ОЧЕРЕДИ');
  149.         writeln('6 - ВЫХОД');
  150. {диалог пользователю о предстоящем вводе}
  151.         write('Выберите один из пунктов меню: ');
  152. {считывание информации вводом с клавиатуры}
  153.         readln(sel);
  154. {выход из цикла осуществляется только тогда, когда пользователь выберет
  155.  допустимый пункт меню, то есть, по сути, небольшая защита от ошибок}
  156.     until((sel >= 1) and (sel <= 6));
  157. {отступ для повышения читабельности}
  158.     writeln;
  159. {возвращение ответа указанного пользователем}
  160.     mainMenu := sel;
  161. {конец тела функции}
  162. end;
  163. {---------------------------------------------------------------------------}
  164. {Функция: определение количества элементов в очереди}
  165. function getCountElem : integer;
  166. var
  167. {вспомогательный указатель, помогающий определить общее количество элементов}
  168.     p : Tptr;
  169. {отвечает за количество элементов в очереди}
  170.     k : integer;
  171. {начало тела функции}
  172. begin
  173. {до обработки количество элементов равно 0}
  174.     k := 0;
  175. {устанавливаем вспомогательный указатель на первый элемент очереди}
  176.     p := begQ;
  177. {чтобы определить общее количество элементов в очереди необходимо циклически
  178.  просмотреть все элементы, поэтому начинаем цикл, который будет продолжаться
  179.  до тех пор, пока указатель р не выйдет за последний элемент, то есть пока
  180.  не выйдет в NIL}
  181.     while(p <> NIL) do
  182.     begin
  183. {увеличиваем счетчик количества элементов на единицу}
  184.         k := k + 1;
  185. {переходим к следующему элементу очереди}
  186.         p := p^.link;
  187.     end;
  188. {в качестве ответа функция возвращает подсчитанное количество элементов}
  189.     getCountElem := k;
  190. {конец тела функции}
  191. end;
  192. {---------------------------------------------------------------------------}
  193. var
  194. {отвечает за пункт меню, выбранный пользователем}
  195.     sel : integer;
  196. {начало главного блока программы}
  197. begin
  198. {очистка экрана от прошлых выводов}
  199.     clrscr;
  200. {изначально в очереди нет элементов, следовательно, чтобы указатель начала
  201.  очереди не "висел" в памяти, необходимо его установить в NIL}
  202.     begQ := NIL;
  203. {циклически отрисовываем меню и просим выбрать пользователя одно из действий
  204.  над очередью до тех пор, пока пользователь не выйдет из программы}
  205.     repeat
  206. {пользователь сделал выбор пункта меню}
  207.         sel := mainMenu;
  208. {используя оператор множественного выбора определяем какую процедуру
  209.  необходимо вызвать}
  210.         case sel of
  211.             1:
  212.             begin
  213. {добавление элемента в конец очереди}
  214.                 addElem;
  215.                 writeln;
  216.                 writeln('Элемент успешно добавлен в конец очереди!');
  217.                 readkey;
  218.             end;
  219.             2:
  220.             begin
  221. {удаление элемента из начала очереди}
  222.                 if(begQ = NIL) then
  223.                     writeln('В очереди нет ни одного элемента! Удаление невозможно!')
  224.                 else
  225.                 begin
  226.                     delElem;
  227.                     writeln('Элемент успешно удален из начала очереди!');
  228.                 end;
  229.                 readkey;
  230.             end;
  231.             3:
  232.             begin
  233. {печать элементов очереди из начала в конец}
  234.                 if(begQ = NIL) then
  235.                     writeln('В очереди нет ни одного элемента! Печать невозможна!')
  236.                 else
  237.                 begin
  238.                     write('Элементы очереди имеют вид: ');
  239.                     printQ;
  240.                 end;
  241.                 readkey;
  242.             end;
  243.             4:
  244.             begin
  245. {рекурсивная печать элементов очереди из конца в начало}
  246.                 if(begQ = NIL) then
  247.                     writeln('В очереди нет ни одного элемента! Печать невозможна!')
  248.                 else
  249.                 begin
  250.                     write('Элементы очереди имеют вид: ');
  251.                     recPrintQ(begQ);
  252.                 end;
  253.                 readkey;
  254.             end;
  255.             5:
  256.             begin
  257. {определяем количество элементов в очереди}
  258.                 writeln('Количество элементов в очереди: ', getCountElem);
  259.                 readkey;
  260.             end;
  261.         end;
  262. {производим выход из цикла, когда пользователь выбрал пункт меню "ВЫХОД"}
  263.     until(sel = 6);
  264. {конец тела главного блока}
  265. end.

РЕПЕТИТОР
ПО ИНФОРМАТИКЕ
И ПРОГРАММИРОВАНИЮ

ЧИТАТЬ
ОТЗЫВЫ МОИХ
УЧЕНИКОВ

Смотреть отзывы

АДРЕС
ЭЛЕКТРОННОЙ ПОЧТЫ
РЕПЕТИТОРА

Написать письмо

ЗАКАЗАТЬ
РАБОТУ ПО
ПРОГРАММИРОВАНИЮ

Работа на заказ

 

 
 
 
 
Авторизация на сайте
 
 
 
Обнаружили
ошибку на сайте?
Занятия по информатике