Учебная работа. Реферат: Линейные списки. Стек. Дек. Очередь

(Пока оценок нет)

Загрузка...

Учебная работа. Реферат: Линейные списки. Стек. Дек. Очередь

Содержание

Введение3

Глава 1. Динамические типы данных_ 6

1.1 Списки. Очередь. Стек. Дек.6

1.2 Динамические информационные структуры_ 22

Глава 2. Разработка факультативного курса «Динамические типы данных»_ 29

2.1 Методические советы по введению факультативного курса в школе29

2.2 Разработка программного средства по теме «Динамические типы данных»_ 38

Заключение42

Литература_ 44

приложение 1. (Листинг программки)45

Введение

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

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

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

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

В простейшей форме таблица быть может линейным перечнем частей. Тогда присущие ей структурные характеристики содержат внутри себя ответы на такие вопросцы, как: «Какой элемент является первым в перечне? какой — крайним? какой элемент предшествует данному либо следует за данным?» М
ожно много гласи
ть о структуре даже в этом совсем тривиальном случае.

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

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

системы обработки списков полез
ны в весьма почти всех вариантах, но при их использовании программер часто сталкивается с лишними
ограничениями.

сейчас целенаправлено найти несколько определений и понятий,
которыми мы будем нередко воспользоваться в предстоящем. информация в таблице представлена обилием
(некие создатели именуют их «записями», «бусинами», «объектами»);
мы время от времени заместо «узел» будем гласить «элемент». Любой узел состоит из 1-го либо нескольки
х поочередных слов в памяти машинки, разбитых на называемые части, именуемые полями. В простом случае узел — это просто одно слово памяти, он имеет лишь одно поле, включающее все слово.

В связи с сиим цель

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

Данной целью определяется последующая догадка:

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

Предмет исследования:

исследование динамических информационных структур.

объект исследования:

Знакомство учащихся с основами программирования.

Достижением цели и согласно поставленной догадки определяются последующие задачки

:

1. Изучить литературу по теме динамические информационные структуры, педагогическую и методическую по теме исследования;

2. Проанализировать виды динамических информационных структур;

3. Создать факультатив по теме исследования;

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

Глава 1. Динамические типы данных

1.1 Списки. Очередь. Стек. Дек.

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

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

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

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

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

1. Получить доступ к k
-му узлу перечня, чтоб проанализировать и/либо поменять содержимое его полей.

2. Включить новейший узел конкретно перед k-ым
узлом.

3. Исключить k-й
узел.

4. Соединить два (либо наиболее) линейных перечня в один перечень.

5. Разбить линейный перечень на два (либо наиболее) перечня.

6. Создать копию линейного перечня.

7. Найти количество узлов в перечне.

8. Выполнить сортировку узлов перечня в вырастающем порядке
по неким полям в узлах.

9. Отыскать в перечне узел с данным значением в неком поле.

Особые случаи k=1 и k=n в операциях (1), (2) и (3)
особо выделяются, так как в линейном перечне проще получить доступ к первому и крайнему элементам, чем к произвольному элементу.

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

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

Почти все люди сообразили значимость стеков и очередей и дали остальные наименования сиим структурам; стек называли пуш-даун
(push-down) перечнем, реверсивной памятью, гнездовой памятью, магазином, перечнем типа LIFO
(«last-in-first-out» — «крайним врубается — первым исключается») и даже употребляется таковой термин, как перечень йо-йо!
Очередь время от времени именуют — повторяющейся памятью либо перечнем типа FIFO («first-in-first-out» — «первым
врубается — первым исключается»).
В течение почти всех лет бухгалтеры употребляли определения LIFO и FIFO как наименования способов при составлении прейскурантов. Еще один термин «архив» применялся к декам с ограниченным
выходом, а деки с ограниченным в
ходом называли «списками»,
либо «реестрами». Такое обилие заглавий любопытно {само по себе}, П
оскольку оно свидетельствует о значимости этих понятий. слова «стек» и «очередь» равномерно стают обычными определениями; из всех остальных словосочетаний, вышеперечисленных, только «пуш-даун перечень» остается еще достаточно всераспространенным, в особенности в теории автоматов.

При описании алгоритмов, использующих такие структуры
, принята особая терминология; так, мы помещаем элемент на
стека либо снимаем верхний элемент. Вниз
у
стека находится менее доступный элемент, и он не удаляется до того времени, пока не будут исключены все остальные элементы. Нередко молвят, что элемент
(push down) в стек либо что стек
(pop up), если исключается верхний элемент. Эта терминология берет свое начало от «стеков» закусок, которые можно повстречать в кафетериях, либо по аналогии с колодами карт в неких перфораторных устройствах. Краткость слов «опустить» и «поднять» имеет свое преимущество, но эти определения неверно подразумевают движение всего перечня в памяти машинки.
На физическом уровне, но, ничего не опускается; элементы просто добавляются сверху, как п
ри стоговании сена либо при укладке кипы коробок. В применении к очередям мы говорим о
и
очереди; объекты встают в конец очереди и удаляются в момент, когда в конце концов добиваются ее начала.
Говоря о деках, мы указываем
и
концы.
понятие верха, низа, начала и конца применимо время от времени и к декам, если они употребляются как стеки либо очереди. Не существует, но, каких-то обычных соглашений относительно того, где должен быть верх, начало и конец: слева либо справа. Таковым образом, мы находим, что в наших методах применимо богатое обилие описательных слов: «сверху — вниз» — для стеков, «слева — вправо» — для деков и «ожидание в очереди

—для очередей.

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

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

На рисунке видно как добавляется и удаляется элемент из двунаправленного перечня. При добавлении новейшего элемента (обозначен N) меж элементами 2 и 3. Связь от 3 идет к N, а от N к 4, а связь меж 3 и 4 удаляется.

В однонаправленном перечне структура прибавления и удаления таковая же лишь связь меж элементами односторонняя.

линейный перечень, в каком все включения выполняются на одном конце перечня, а все исключения (и обычно всякий доступ) делаются на другом его конце.

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

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

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

Иными словами, у очереди есть голова
(head) и хвост
(tail). Элемент, добавляемый в очередь, оказывается в её хвосте, как что подошедший клиент; элемент, удаляемый из очереди, находится в её голове, как тот клиент, что отстоял подольше всех.

В очереди новейший элемент добавляется лишь с 1-го конца. Удаление элемента происходит на другом конце. В данном случае это быть может лишь 4 элемент. Очередь на самом деле однонаправленный перечень, лишь добавление и исключение частей происходит на концах перечня.

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

часть памяти ОЗУ компа, которая предназначается для временного хранения байтов, применяемых процессором; при всем этом употребляется порядок запоминания байтов «крайним вошел – первым вышел», так как такие ввод и вывод организовывать проще всего, также операции осуществляются весьма стремительно. Деяния со стеком делается с помощью регистра указателя стека. Хоть какое повреждение данной нам части памяти приводит к фатальному сбою.

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

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

Стеки весьма нередко встречаются в практике. Обычным примером может служить ситуация, когда мы просматриваем огромное количество данных и составляем перечень особенных состояний либо объектов, которые должны обрабатываться позже; когда первоначальное огромное количество обработано, мы возвращаемся к этому списку и исполняем следующую обработку, удаляя элементы из перечня, пока перечень не станет пустым. Для данной нам цели подходящи как стек, так и очередь, но стек, как правило, удобнее. При решении задач наш обычно расположенный в головном отделе тела и представляющий из себя малогабаритное скопление мозг важной для организма информаци) клеток и их отростков»> обычно расположенный в головном отделе тела и представляющий собой компактное скопление нервных клеток и их отростков»>мозг ведет себя как «стек»: одна неувязка приводит к иной, а та в свою очередь к последующей; мы накапливаем в стеке эти задачки и подзадачи и удаляем их по мере того, как они ре
шаются. Аналогично процесс входов в подпрограммы и выходов из их при выполнении машинной программки подобен процессу функционирования стека. Стеки в особенности полезны при обработке языков, имеющих структуру вложений. К ним относятся языки программирования, арифметические выражения и
германские «Schachtelsatze» /практически «вложенные предложения«/
. Совершенно, стеки почаще всего появляются в связи с методами, имеющими очевидно либо неявно рекурсивный нрав.

Представьте для себя, что четыре жд вагона находятся на входной стороне пути (рис. 1) и перенумерованы соответственно 1, 2, 3 и 4. Представим, что мы исполняем последующую последовательность операций (которые согласуются
с направлением стрелок на рисунке и не требуют, чтоб вагоны «перепрыгивали» друг через друга). Отправьте:

(а) вагон 1 в стек;

(b) вагон 2 в стек;

(с) вагон 2 на выход;

(d) вагон 3 в стек;

(е)
вагон 4 в стек;

(f) вагон 4 на выход;

(g) вагон 3 на выход;

(h) вагон 1 на выход.

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

В стеке элемент добавляется и удаляется лишь с 1-го конца. На рисунке это элемент N. Другими словами если он добавился, то удаляется может поначалу лишь он, а уж позже все другие.

Стек можно представить для себя как коробку, в которую складывают какие-нибудь предметы, чтоб достать самый нижний необходимо за ранее вынуть другие. Сте
к можно уподобить стопке тарелок, из которой можно взять верхнюю и на которую можно положить новейшую тарелку. [Другое заглавие стека в российской литературе — «магазин» — понятно всякому, кто разбирал автомат Калашникова]
.

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

время от времени осознать механ
изм стека. На рис. 2. Изображен дек в виде жд разъезда.

Как следует, дек владеет большей общностью, чем стек либо очередь; он имеет некие общие характеристики с колодой карт (в британском языке эти слова созвучны). Мы будем различать деки с
либо
в таковых деках соответственно исключение либо включение допускается лишь на одном конце.

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

В

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

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

Иными словами, элемент двусторонне связанного перечня

это запись, содержащая три поля:
(ключ) и два указателя —
(последующий) и

(от previous—предшествующий). Кроме этого, элементы перечня могут содержать доп данные. Если

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

— на предыдущий. Если prev
{х}=
nil,
то у элемента
нет предыдущего: этоголова (head) перечня. Если next{х}=
nil,
то
— крайний элемент перечня либо, как молвят, егохвост (tail).

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

(sin
gly linked)

перечне отсутствуют поля
В

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

перечня.

поле
головы перечня указ
ывает на хвост перечня, а поле
хвоста перечня показывает на голову перечня.

Если другое не обсуждено особо, под перечнем мы будем осознавать неупорядоченный двусторонне связанный перечень.

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

тут А, В, С, D и Е— произвольные ячейки в памяти, а Л — пустая связь. программка, в какой употребляется таковая таблица, имела бы, в случае поочередного распределения, доп переменную либо константу, случае связанного распределения в программке имеется переменная связи либо константа, которая показывает на А, а отправляясь от А, можно отыскать все остальные элементы перечня.

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

тут FIRST
— переменная связи, указывающая на 1-ый узел в перечне.

сейчас мы можем сравнить эти две главные формы хранения инфы:

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

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

3) Если употребляется сплетенная схема, то просто включить элемент в перечень. к примеру, чтоб включить элемент в (1), нужно поменять только две связи:

Таковая операция заняла бы существенное время при работе с длинноватой поочередной таблицей.

4) При поочередном распределении существенно резвее производятся воззвания к произвольным частям перечня. Доступ к k-му элементу перечня, если
переменная, для поочередного распределения занимает фиксированное время, а для связанного — нужно
итераций, чтоб добраться до требуемого ме
100. Таковым образом, полезность связанной памяти основывается на том факте, что в большущем большинстве приложений мы будем продвигаться по списку поочередно, а не произвольным образом; если нам нужны элементы посреди либо в нижней части перечня, то попытаемся завести доп переменную связи либо перечень переменных связи, которые указывают на надлежащие места в перечне.

5) При использовании схемы со связями упрощается задачка объединения 2-ух списков либо разбиения перечня на части.

6) Схема со связями годится для структур наиболее сложных, чем обыкновенные линейные списки. У нас быть может переменное количество списков, размер которых непостоянен; хоть какой узел 1-го перечня быть может началом другого перечня; в одно и то же время узлы могут быть соединены в несколько последовательностей, соответственных разным перечням, и т.д.

7) На почти всех машинках обыкновенные операции, такие, как последовательное продвижение по списку, производятся несколько резвее для поочередных списков.

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

В последующих нескольких примерах мы будем ради удобства полагать, что узел — это одно слово и что оно разбито на два поля INFO и LINK:

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

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

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

Представим, в узлах имеется два поля: INFO и LINK. Переменная связи PTR показывает на самый правый узел перечня, a LINK (PTR) является адресом самого левого узла.

Различного рода расщепления 1-го повторяющегося перечня на два, соответствуют операциям конкатенации (объединения) и деконкатенации (разъединения) цепочек.

Таковым образом, мы лицезреем, что циклические списки можно употреблять не только лишь для представления структур, которым характерна цикличность, но также для представления линейных структур; повторяющийся перечень с одним указателем на крайний узел, по существу, эквивалентен обычному линейному списку с 2-мя указателями на начало и конец. В связи с сиим наблюдением возникает естественный вопросец: Как отыскать конец перечня, имея в виду радиальную симметрию? Пустой связи Л, которая отмечает конец, не существует. неувязка решается так: если мы исполняем некие операции, двигаясь по списку от 1-го узла к последующему, то мы должны тормознуть, когда мы возвратились к начальному месту (предполагая, естественно, что начальное пространство все еще находится в перечне).

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

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

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

EMBED Equation.3
на EMBED Equation.3 ,

дающему в итоге

EMBED Equation.3

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

1.2 Динамические информационные структуры

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

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

В языке Паскаль предусмотрена возможность использования динамических
величин. Для их выделение и чистка памяти происходит не на шаге трансляции, а в процессе выполнения самой программки. Для работы с динамическими величинами в Паскале предусмотрен особый тип значений —
Этот тип не относится ни к обычным, ни к составным.
Переменные ссылочного типа, либо
являются статическими переменными. Значением переменной ссылочного типа является адресок ячейки — места в памяти соответственной динамической величины. Свое момент возникновения соответственной динамической величины.

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

Значением указателя является адресок ячейки, начиная с которой будет расположена в памяти соответственная динамическая в
еличина.

На данной нам схеме р. — имя указателя; звездо
чкой изображено значение указателя, а стрелка отражает тот факт, что значением указателя является адресок объекта (ссылка на объект), средством которого объект и доступен в программке.

В неких вариантах возникает необходимость в качестве значения указателя прин
ять «пустую» ссылку, которая не связывает с указателем никакого объекта. Такое

Процедура new(i) делает две функции:

1) резервирует пространство в памяти для размещения динамического объекта соответственного типа с именованием i;

2) указателю i
присваивает адресок динамического объекта i.

Но, выяснить адресок динамической переменной при помощи процедуры writeln (i) недозволено.

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

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

Если в процессе выполнения программки некий динамический объект р^,
сделанный в итоге выполнения оператора new(
p), становится ненадобным, то его можно убить (очистить выделенное ему пространство в памяти) при помощи обычной процедуры dispose(p). В итоге выполнения оператора вида dispose(p) динамический объект, на который показывает ссылочная переменная р, прекращает свое существование, занимаемое им пространство в памяти становится вольным, а

Если до вызова процедуры dispose(p) имел пустое

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

Значение 1-го указателя можно присвоить другому указателю такого же типа. Можно также указатели схожего типа ассоциировать друг с другом, используя дела «=»
либо «о».

Обычные процедуры new и dispose разрешают динамически порождать программные объекты и уничтожать их, что дает возможность употреблять память машинки наиболее отлично.

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

а) неопределенное заблаговременно число частей;

б) необходимость хранения в оперативки.

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

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

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

а) связывание следующих компонент стека;

б) смещение ссылок при любом движении по стеку.

Из-за необходимости хранить не только лишь (элементу, который пришел первым, ссылаться не на что, о чем свидетельствует «пустая ссылка» nil).

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

Type

List = ^Spisok; —

Spisok = record

Info: Integer; —

Next: List; —

end;

ListTwo = ^SpisokTwo; —

SpisokTwo = record

Info: Integer; —

Next: ListTwo; —

Prev: ListTwo; —

end;

Создание перечня

procedure CreateLists; —

begin

X := Random(101); Определяем

Uk := nil;

q := nil;

AddToList (X, Uk);

q := Uk;
.

for i := 1 to 9 do

begin

X := Random(101);

AddToList (X, q);

end;

ListBegin := Uk;

end;

Ликвидирование перечня

procedure DestroyList (PointerBegin: List);

begin

while PointerBegin <> nil do

begin

q := PointerBegin;

PointerBegin := PointerBegin ^.Next;

if q <> nil then Dispose(q);

end;

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

procedure AddToList(X: Integer; var PointerEndList: List);

)

begin

if PointerEndList = nil then

begin

New(PointerEndList);

PointerEndList ^.Info := X;

PointerEndList ^.Next := nil;

end

else

begin

New(PointerEndList ^.Next);

PointerEndList := PointerEndList ^.Next;

PointerEndList ^.Info := X;

PointerEndList ^.Next := nil;

end;

Удаление элемента из перечня.

procedure DeleteFromList(Position: Integer);

begin

q := ListBegin;

if q <> nil then

begin

if Position = 0 then

begin

ListBegin := q^. Next;

if q <> nil then Dispose(q);

end

else

begin

i := 0;

while (i < Position — 1) and (q <> nil) do

begin

q := q^. Next;

Inc(i);

end;

r := q^. Next;

if r <> nil then

begin

q^. Next := r^. Next;

if r <> nil then Dispose(r);

end

end;

end

end;

Глава 2. Разработка факультативного курса «Динамические типы данных»

2.1 Методические советы по введению факультативного курса в школе

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

Разработанный нами факультатив рассчитан на 14 часов.

задачки факультатива:

1) Ввести понятие линейного перечня, однонаправленного и двунаправленного перечня, повторяющегося перечня, стека, дека и очереди;

2) Сформировать познавательный Энтузиазм у учащихся к информатике;

3) Развить у учащихся творческие возможности.

Цель первого урока – отдать учащимся на высококачественном уровне нужный предварительный материал, который содержит в себе:

1) Определение линейного перечня.

2) Операции со перечнями.

3) Виды списков.

4) Связанное распределение.

5) Динамические переменные.

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

Общая структура факультатива такая:

№ урока

Тема

Кол-во часов

№1.
Списки
2

№2.
Однонаправленный и двунаправленный перечень
2

№3.
Повторяющийся перечень
2

№4.
Очередь
2

№5.
Стек
2

№6.
Дек
2

№7.
тест
2

Конспекты уроков

Тема: «Очередь»

Цели:

1. Раскрыть понятие линейного перечня «Очередь».

2. Научиться употреблять «Очередь» на практике при решении задач.

3. Сформировать у учащихся познавательный Энтузиазм к информатике.

№

Шаг урока

время (мин.)

1.
Организационный момент
2

2.
Подготовка к лабораторной работе
10

3.
Выполнение лабораторной работы
20

4.
Закрепление
8

Лабораторная работа №4 по теме «Очередь».

1. Нажмите клавишу «Теория» для очереди.

Пристально изучите теоретический материал.

2. Нажмите клавишу «Обновить» для формирования списков.

Клавиши «<< и >>» служат для перемещения курсора по очереди.

а) Переместитесь на Право до 3 элемента;

б) Переместитесь на лево (см. коментарии);

Клавиша «Добавить» служит для прибавления элемента в очередь.

а) Добавьте 1, 4, 5-м элементами число 99;

б) Добавьте крайним число 999;

Клавиша «Удалить» служит для удаления элемента из очереди.

Удалите 1, 2, 3 элементы;

3. На листе формата А4, опишите ход проделанной работы.

Ответьте на поставленные вопросцы:

1) Как удаляется и добавляется элементы в очереди?

2) В чем различие и сходство очереди и однонаправленного перечня?

3) Что именуется головой и хвостом очереди?

4) Как размещаются элементы в очереди?

________________________________________________________________

задачки для самостоятельного решения:

1) Пусть уже построена очередь Q, содержащая целые числа. Вычислить сумму и произведение частей, находящихся в очереди.

2) Пусть уже построена очередь Q, содержащая целые числа. Сформировать новейшую очередь P, состоящую из частей очереди Q, кратных числу 3.

3) Пусть уже построена очередь Q, содержащая целые числа. Вычислить количество обычных чисел, находящихся в очереди.

Учитель

Ученик

ПК

Тетрадь

Запускаем демонстрационную программку. Нажмите клавишу теория. Перед вами возникло окно с теоретическим материалом. Пристально ознакомьтесь с новеньким материалом. Обратите внимание на примеры сотворения очереди и получения элемента из очереди. Провести аналогию меж очередью и однонаправленным перечнем.
Знакомится с новеньким материалом.
Теоретический материал по теме «очередь».

Определение «очереди».

порядок расположения данных.

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

Открываем лабораторную работу №4.

Пристально читаем задание и начинаем делать.

Делает лабораторную работу.
Лабораторная работа
№4.

Опосля выполнения заданий ответьте на поставленные вопросцы.
Отвечает на вопросцы.
Ответы на вопросцы.

Попытайтесь выполнить практические задания.
Решает задачки.
Delphi либо Pascal.
Листинг задачки.

Итак, давайте подведем итоги нынешней работы.

Что именуется очередью?
Очередь — линейный перечень, в каком все включения выполняются на одном конце перечня, а все исключения на другом конце.

Как размещаются данные в очереди?
Очередь — тип данных, при котором новейшие данные размещаются следом за имеющимся в порядке поступления;

Какие данные в очереди обрабатываются первыми?
Данные поступившие первыми обрабатываются первыми.

Что такое «голова», «хвост» очереди?
Элемент, добавляемый в очередь, оказывается в её хвосте. Элемент, удаляемый из очереди, находится в её голове.

В чем идентичны очередь и однонаправленный перечень?

Очередь, на самом деле, однонаправленный перечень, лишь

добавление и исключение частей происходит на концах перечня.

Тема: «Стек»

Цели:

1. Раскрыть понятие линейного перечня «Стек».

2. Научиться употреблять «Стек» на практике при решении задач.

3. Сформировать у учащихся познавательный Энтузиазм к информатике.

№

Шаг урока

время (мин.)

1.
Организационный момент
2

2.
Подготовка к лабораторной работе
10

3.
Выполнение лабораторной работы
20

4.
Закрепление
8

Лабораторная работа №5 по теме «Стек».

1. Нажмите клавишу «Теория» для стека.

Пристально изучите теоретический материал.

2. Нажмите клавишу «Обновить» для формирования списков.

Клавиши «<< и >>» служат для перемещения курсора в стеке.

а) Переместитесь на Право до 4 элемента;

б) Переместитесь на лево (см. комменты);

Клавиша «Добавить» служит для прибавления элемента в стек.

Добавьте 1, 3, 5 элементами число 22;

Клавиша «Удалить» служит для удаления элемента из стека.

Удалите 1, 3, 5, крайний элементы;

3. На листе формата А4, опишите ход проделанной работы.

Ответьте на поставленные вопросцы:

1) Как удаляется и добавляется элементы в стек?

2) Приведи примеры стека на практике?

________________________________________________________________

задачки для самостоятельного решения:

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

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

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

Учитель

Ученик

ПК

Тетрадь

Запускаем демонстрационную программку. Нажмите клавишу теория. Перед вами возникло окно с теоретическим материалом. Пристально ознакомьтесь с новеньким материалом. Обратите внимание на примеры сотворения стека и получения элемента из стека. Провести аналогию меж очередью и стеком.
Знакомится с новеньким материалом.
Теоретический материал по теме «стек».

Определение «стека».

порядок расположения данных.

Примеры сотворения стека и получения элемента из стека.

Открываем лабораторную работу №5.

Пристально читаем задание и начинаем делать.

Делает лабораторную работу.
Лабораторная работа
№5.

Опосля выполнения заданий ответьте на поставленные вопросцы.
Отвечает на вопросцы.
Ответы на вопросцы.

Попытайтесь выполнить практические задания.
Решает задачки.
Delphi либо Pascal.
Листинг задачки.

Итак, давайте подведем итоги нынешней работы.

Что именуется стеком?

Стек — линейный перечень, в каком все включения и

исключения делаются в одном конце перечня.

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

Различия меж очередью и стеком?

постоянно самый «старший» элемент; узлы покидают перечень в том

порядке, в каком они в него вошли.

Тема: «Тест»

Цели:

1. Закрепить приобретенные познания по пройденному курсу.

2. Узнать результативность приобретенных познаний при помощи теста.

3. Сформировать у учащихся познавательный Энтузиазм к информатике.

№

Шаг урока

время (мин.)

1.
Организационный момент
2

2.
Подготовка к тесту
10

3.
тест
20

4.
Подведение итогов
8

Лабораторная работа №7 по теме «Тест».

1. Повторите весь теоретический материал.

2. Поработайте с демонстрационной программкой.

3. Запустите тест (сервистест либо Ctrl + T).

4. Ответьте на поставленные вопросцы теста.

5. Результаты теста сказать педагогу.

Учитель

Ученик

ПК

Тетрадь

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

определения списков.

Включение и исключение частей из списков. Общее и различия меж перечнями.

Запускаем тест. (Меню: СервисТест). Перед вами возникло окно «Тест». В верхнем левом поле предлагается вопросец, ниже под полем предлагаются на выбор несколько вариантов ответов. Правой кнопкой мыши щелкаете на верный по вашему воззрению ответ. Опосля выбора ответа, клавиша «Дальше» становится активной, нажимаете ее. Опосля нажатия на клавишу «Дальше», покажется последующий вопросец.

Продолжаете дальше, пока не покажется оценка за тест.

Тестируется.

Тест.

Итог сообщите учителю.
Оценка за тест.

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

Итак, мы с вами исследовали линейные списки.

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

С помощью теста оценили результаты приобретенных познаний.

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

Сообщаются оценки за тест, и за факультатив в общем.

2.2 Разработка программного средства по теме «Динамические типы данных»

Опосля загрузки демонстрационной программки перед вами покажется вот такое окно.

Это основная форма демонстрационной программки. Для формирования списков нажмите клавишу «Обновить».

сейчас списки сформированы и готовы к работе. Списки содержат целые положительные числа. Указатели указывают на начало перечня. При помощи клавиш «<<» «>>» можно перемещать указатель по списку. При помощи клавиши «Добавить» вы сможете добавить элемент в перечень. При нажатии на клавишу «Добавить» всплывает окно «Добавление новейшего элемента», в каком вы указываете какой элемент желаете добавить и нажимаете клавишу «Ok».

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

При нажатии на клавишу теория (для очереди) раскрывается окно «Очередь», котором изложена теория и даны примеры.

Аналогично для других списков.

Для наиболее комфортной работы с учащимися в программке предусмотрены лабораторные работы (Ctrl + L либо Сервис Лабораторные работы). Если вы выберете все то раскроется окно «Лабораторные работы», в каком даны сходу все работы и задания. Перед вами 4 лабораторная работа на перечень «Очередь».

Если вы будете выбирать каждую в отдельности то они будут отображаться в комментах на главной форме.

Помощь можно вызвать (СправкаПомощь либо F1).

Опосля проведения всех лабораторных работ учащимся предлагается ответить на вопросцы теста, за который они получают оценку. При запуске теста (Сервистест либо Ctrl + T) раскрывается окно «Тест».

Сверху вопросец, ниже варианты ответов. Опосля выбора ответа клавиша «Дальше» становится активной, нажав на нее возникает последующий вопросец. Опосля выполнения теста выдается оценка, если неудовлетворительная то раскрывается окно «Лабораторные работы».

опосля того как тест запустился вызов теста становится неактивным т.е. 2-ой раз учащийся запустить тест не сумеет.

Закрыть программку можно нажатием на клавишу «Закрыть» либо F10.

Заключение

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

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

Достижением данной нам цели и согласно поставленной догадки определялись последующие задачки:

2. Проанализировать виды динамических информационных структур;

3. Создать факультатив по теме исследования;

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

Все поставленные цели и задачки реализованы в данной квалификационной работе. Исследовано понятие линейного перечня, различные операции с сиим перечнем, определяются главные определения и понятия. Не считая того, рассматривается наиболее непосредственно и много любой перечень в отдельности и показывается необходимость использования списков в тех либо других вариантах. Для всякого перечня приводятся актуальные примеры для простоты восприятия. Дается понятие связанного распределения и коротко изучается понятие динамических информационной структуры, которая разрешают применить приобретенные познания при программировании. Также рассматривается преимущество и недочеты 2-ух форм представления инфы: связанное и последовательное. Дальше следует методическая часть, в какой представлена расчасовка факультатива, его структура, и поставлены цели и задачки факультатива. Приводится для примера три конспекта уроков по теме «Очередь», «Стек» и «Тест». И крайнее это управление юзера, в каком дается описания работы с демонстрационной программкой.

Литература

1. Айен Синклер «Большенный толковый словарь компьютерных определений», М.: 1998 г.

2. Архангельский А. Я. «Программирование в Delphi 4», М.: 1999 г.

3. Архангельский А. Я. «Программирование в Delphi 5», М.: 2000 г.

4. Вирт Н. «Методы и структуры данных», Москва Изд. мир, 1989 г.

5. Гудмэн Д. «Управление памятью для всех», Киев 1995 г.

6. Зубов В. С. «Справочник программера», М.: 1999 г.

7. Ремень Д. «Искусство программирования для ЭВМ », т.1 Главные методы, Изд. мир М.: 1976 г.

8. Кормен Т. и остальные «Методы построения и анализ», М.: 2000 г.

9. Подласый И. П. Учебник для студентов высших педагогических учебных заведений, М.: Просвещение 1996 г.

10. Усова А. В. «Формирование у школьников понятий в процессе обучения», М.: Педагогика, 1986 г.

приложение 1. (Листинг программки
)

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

unit Unit1; //
интерфейс

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, ExtCtrls, StdCtrls, ComCtrls, Unit2, Unit3, Unit4, Unit5, Unit6, Unit7, Unit8, Unit9, Menus, Unit11, Unit12, Unit13, Unit14, Unit15, Unit16, Unit17;

type

TForm1 = class(TForm)

Panel1: TPanel;

Edit1: TEdit;

Label1: TLabel;

Button1: TButton;

Button2: TButton;

Button3: TButton;

Button4: TButton;

Panel2: TPanel;

Label2: TLabel;

Edit2: TEdit;

Button5: TButton;

Button6: TButton;

Button7: TButton;

Button8: TButton;

Panel3: TPanel;

Label3: TLabel;

Edit3: TEdit;

Button9: TButton;

Button10: TButton;

Button11: TButton;

Button12: TButton;

Panel4: TPanel;

Label4: TLabel;

Edit4: TEdit;

Button13: TButton;

Button14: TButton;

Button15: TButton;

Button16: TButton;

Panel5: TPanel;

Label5: TLabel;

Edit5: TEdit;

Button17: TButton;

Button18: TButton;

Button19: TButton;

Button20: TButton;

Panel6: TPanel;

Edit6: TEdit;

Label6: TLabel;

Button21: TButton;

StatusBar1: TStatusBar;

Image1: TImage;

Image2: TImage;

Image3: TImage;

Image4: TImage;

Image5: TImage;

Button22: TButton;

Memo1: TMemo;

Label7: TLabel;

Image6: TImage;

Bevel1: TBevel;

Panel7: TPanel;

Button23: TButton;

Button24: TButton;

Button25: TButton;

Button26: TButton;

Edit7: TEdit;

Image7: TImage;

Label8: TLabel;

Panel8: TPanel;

Image8: TImage;

MainMenu1: TMainMenu;

N1: TMenuItem;

N2: TMenuItem;

N3: TMenuItem;

N4: TMenuItem;

N5: TMenuItem;

Button27: TButton;

Button28: TButton;

Button30: TButton;

Button29: TButton;

Button31: TButton;

Button32: TButton;

N6: TMenuItem;

N7: TMenuItem;

N8: TMenuItem;

N11: TMenuItem;

N21: TMenuItem;

N31: TMenuItem;

N41: TMenuItem;

N51: TMenuItem;

N61: TMenuItem;

N71: TMenuItem;

Button33: TButton;

N9: TMenuItem;

procedure Button12Click(Sender: TObject);

procedure Button11Click(Sender: TObject);

procedure Button22Click(Sender: TObject);

procedure Button21Click(Sender: TObject);

procedure Button1Click(Sender: TObject);

procedure Button3Click(Sender: TObject);

procedure Button4Click(Sender: TObject);

procedure Button7Click(Sender: TObject);

procedure Button8Click(Sender: TObject);

procedure FormClose(Sender: TObject; var Action: TCloseAction);

procedure Button15Click(Sender: TObject);

procedure Button16Click(Sender: TObject);

procedure Button20Click(Sender: TObject);

procedure FormCreate(Sender: TObject);

procedure Button19Click(Sender: TObject);

procedure Button5Click(Sender: TObject);

procedure Button2Click(Sender: TObject);

procedure Button6Click(Sender: TObject);

procedure Button10Click(Sender: TObject);

procedure Button9Click(Sender: TObject);

procedure Button14Click(Sender: TObject);

procedure Button13Click(Sender: TObject);

procedure Button17Click(Sender: TObject);

procedure Button18Click(Sender: TObject);

procedure Button26Click(Sender: TObject);

procedure Button25Click(Sender: TObject);

procedure Button23Click(Sender: TObject);

procedure Button24Click(Sender: TObject);

procedure N2Click(Sender: TObject);

procedure N5Click(Sender: TObject);

procedure N4Click(Sender: TObject);

procedure Button27Click(Sender: TObject);

procedure Button30Click(Sender: TObject);

procedure Button29Click(Sender: TObject);

procedure Button31Click(Sender: TObject);

procedure Button32Click(Sender: TObject);

procedure N8Click(Sender: TObject);

procedure N11Click(Sender: TObject);

procedure Button33Click(Sender: TObject);

procedure N21Click(Sender: TObject);

procedure N31Click(Sender: TObject);

procedure N41Click(Sender: TObject);

procedure N51Click(Sender: TObject);

procedure N61Click(Sender: TObject);

procedure N71Click(Sender: TObject);

procedure N9Click(Sender: TObject);

private

public

end;

procedure DoNewEditList;

procedure DoNewEditListTwo;

procedure DoNewEditRoundList;

var

Form1: TForm1;

ListBegin: List; //указатель на однонапр. перечень

ListPos: Integer; //позиция в однонапр. перечне

ListTwoBegin: ListTwo; //указатель на двунапр. перечень

ListTwoPos: Integer; //позиция в двунапр. перечне

QueueBegin: List; //указатель на очередь

QueuePos: Integer; //»позиция в очереди» (содержит кол-во знаков в Edit до первого элемента)

Stack: List; //указатель на стек

StackPos: Integer; //»позиция в стеке» (содержит кол-во знаков в Edit до первого элемента)

DeckBegin, DeckEnd: ListTwo; //указатели на начало и конец дека

DeckBeginPos, DeckEndPos: Integer; //»позиции в деке» (DeckEndPos содержит кол-во знаков в Edit от DeckEndPosition до крайнего элемента)

DeckEndPosition: Integer; //позиция крайнего элемента в деке (содержит первоначальное кол-во знаков в Edit до крайнего элемента)

RoundList: List; //указатель в повторяющемся перечне

RoundListPos: Integer; //»позиция в повторяющемся перечне»

implementation

uses O_programm, Help, Un18_Lab;

{$R *.DFM}

procedure DoNewEditList;

var

q: List;

begin

q := ListBegin;

Form1.Edit1.Text := »;

while q <> nil do

begin

Form1.Edit1.Text := Form1.Edit1.Text + ‘ ‘ + IntToStr(q^.Info);

q := q^.Next;

end;

procedure DoNewEditListTwo;

var

q: ListTwo;

begin

q := ListTwoBegin;

Form1.Edit2.Text := »;

while q <> nil do

begin

Form1.Edit2.Text := Form1.Edit2.Text + ‘ ‘ + IntToStr(q^.Info);

q := q^.Next;

end;

procedure DoNewEditRoundList;

var

q: List;

begin

q := RoundList^.Next;

Form1.Edit7.Text := ‘ ‘ + IntToStr(RoundList^.Info);

while q <> RoundList do

begin

Form1.Edit7.Text := Form1.Edit7.Text + ‘ ‘ + IntToStr(q^.Info);

q := q^.Next;

end;

procedure TForm1.Button12Click(Sender: TObject);

var

i, j: Integer;

s: string;

begin

StatusBar1.Panels[0].Text := »;

GetQueue(QueueBegin);

if QueueBegin <> nil then

begin

while Edit3.Text[QueuePos] <> ‘ ‘ do Inc(QueuePos);

Inc(QueuePos);

s := Edit3.Text;

for i := 1 to QueuePos — 1 do

if s[i] <> ‘ ‘ then s[i] := ‘ ‘;

Edit3.Text := s;

end

else

begin

ShowMessage(‘Очередь пуста’);

Edit3.Text := »;

Image3.Hide;

Button10.Enabled := False;

Button11.Enabled := False;

Button12.Enabled := False;

StatusBar1.Panels[1].Text := ‘Очередь пуста’;

end;

Image3.Left := Round(QueuePos * 7);

end;

procedure TForm1.Button11Click(Sender: TObject);

begin

StatusBar1Panels[0].Text := ‘недозволено !!!’;

Memo1.Lines.Add(‘В очерди недозволено ворачиваться в начало т.к. указатель показывает сходу на начало;’);

end;

procedure TForm1.Button22Click(Sender: TObject);

begin

Application.Terminate;

end;

procedure TForm1.Button21Click(Sender: TObject);

var

q: List;

qTwo: ListTwo;

qQueue, rQueue: List;

Info: Integer;

FlagList: Boolean;

qStack: List;

qDeckBegin, qDeckEnd: ListTwo;

qRoundList: List; // начало циклич. перечня

begin

Button1.Enabled := True;

Button2.Enabled := True;

Button3.Enabled := True;

Button4.Enabled := True;

Button5.Enabled := True;

Button6.Enabled := True;

Button7.Enabled := True;

Button8.Enabled := True;

Button9.Enabled := True;

Button10.Enabled := True;

Button11.Enabled := True;

Button12.Enabled := True;

Button13.Enabled := True;

Button14.Enabled := True;

Button15.Enabled := True;

Button16.Enabled := True;

Button17.Enabled := True;

Button18.Enabled := True;

Button19.Enabled := True;

Button20.Enabled := True;

Button23.Enabled := True;

Button24.Enabled := True;

Button25.Enabled := True;

Button26.Enabled := True;

Image1.Visible := True;

Image2.Visible := True;

Image3.Visible := True;

Image4.Visible := True;

Image5.Visible := True;

Image6.Visible := True;

Image7.Visible := True;

Edit1.Text := »;

Edit2.Text := »;

Edit3.Text := »;

Edit4.Text := »;

Edit5.Text := »;

Edit7.Text := »;

StatusBar1.Panels[0].Text := »;

StatusBar1.Panels[1].Text := »;

CreateLists;

q := ListBegin;

qTwo := ListTwoBegin;

while q <> nil do

begin

Edit1.Text := Edit1.Text + ‘ ‘ + IntToStr(q^.Info);

q := q^.Next;

end;

Image1.Left := 9;

ListPos := 0;

while qTwo <> nil do

begin

Edit2.Text := Edit2.Text + ‘ ‘ + IntToStr(qTwo^.Info);

qTwo := qTwo^.Next;

end;

Image2.Left := 9;

ListTwoPos := 0;

FlagList := True;

while QueueBegin <> nil do

begin

Info := GetQueue(QueueBegin);

Edit3.Text := Edit3.Text + ‘ ‘ + IntToStr(Info);

AddToQueue(Info, qQueue);

if FlagList then

begin

FlagList := False;

rQueue := qQueue;

end;

QueueBegin := rQueue;

QueuePos := 2;

Image3.Left := 9;

while Stack <> nil do

begin

Info := GetStack(Stack);

Edit4.Text := Edit4.Text + ‘ ‘ + IntToStr(Info);

AddToStack(Info, qStack);

end;

Stack := qStack;

Memo1.Lines.Add(‘В стеке числа идут на оборот т.к. элементы считываются из конца стека.’);

StackPos := 2;

Image4.Left := 9;

while DeckEnd <> nil do

begin

Info := GetDeckEnd(DeckEnd);

Edit5.Text := Edit5.Text + ‘ ‘ + IntToStr(Info);

AddToDeck(Info, qDeckBegin, qDeckEnd, 0);

end;

DeckBegin := qDeckBegin;

DeckEnd := qDeckEnd;

DeckBeginPos := 2;

Image5.Left := 9;

Memo1.Lines.Add(‘Дек прочитывался с начала, потому элементы записались по порядку.’);

DeckEndPosition := 1;

while Edit5.Text[DeckEndPosition] <> » do Inc(DeckEndPosition);

Image6.Left := Round(9 + DeckEndPosition * 6.2);

Dec(DeckEndPosition);

DeckEndPos := DeckEndPosition;

qRoundList := RoundList^.Next;

Edit7.Text := ‘ ‘ + IntToStr(RoundList^.Info);

while qRoundList <> RoundList do

begin

Edit7.Text := Edit7.Text + ‘ ‘ + IntToStr(qRoundList^.Info);

qRoundList := qRoundList^.Next;

end;

Image7.Left := 9;

RoundListPos := 0;

end;

procedure TForm1.Button1Click(Sender: TObject);

begin

Form3.Show;

end;

procedure TForm1.Button3Click(Sender: TObject);

begin

StatusBar1.Panels[0].Text := ‘недозволено !!!’;

Memo1.Lines.Add(‘В однонаправленном перечне недозволено передвигаться вспять, т.к. связь существует толко в одну сторону;’);

end;

procedure TForm1.Button4Click(Sender: TObject);

var

qList: List;

i, j: Integer;

begin

StatusBar1.Panels[0].Text := »;

qList := ListBegin;

i := 0;

while i <> ListPos do

begin

qList := qList^.Next;

Inc(i);

end;

if qList <> nil then

begin

if qList^.Next <> nil then Inc(ListPos);

i := 0;

j := 0;

while i < ListPos do

begin

Inc(j);

if Edit1.Text[j] = ‘ ‘ then Inc(i);

end;

Image1.Left := Round(9 + (j + 1) * 7.5);

end;

procedure TForm1.Button7Click(Sender: TObject);

var

qListTwo: ListTwo;

i, j: Integer;

begin

StatusBar1.Panels[0].Text := »;

qListTwo := ListTwoBegin;

i := 0;

if ListTwoPos <> 0 then dec(ListTwoPos);

i := 0;

j := 0;

while i < ListTwoPos do

begin

Inc(j);

if Edit2.Text[j] = ‘ ‘ then Inc(i);

end;

if ListTwoPos = 0 then Image2.Left := 9

else Image2.Left := Round(9 + (j + 1) * 7.5);

end;

procedure TForm1.Button8Click(Sender: TObject);

var

qListTwo: ListTwo;

i, j: Integer;

begin

StatusBar1.Panels[0].Text := »;

qListTwo := ListTwoBegin;

i := 0;

while i <> ListTwoPos do

begin

qListTwo := qListTwo^.Next;

Inc(i);

end;

if qListTwo <> nil then

begin

if qListTwo^.Next <> nil then Inc(ListTwoPos);

i := 0;

j := 0;

while i < ListTwoPos do

begin

Inc(j);

if Edit2.Text[j] = ‘ ‘ then Inc(i);

end;

Image2.Left := Round(9 + (j + 1) * 7.5);

end;

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);

begin

DestroyList(ListBegin);

DestroyListTwo(ListTwoBegin);

DestroyList(QueueBegin);

DestroyList(Stack);

DestroyListTwo(DeckBegin);

Application.Terminate;

end;

procedure TForm1.Button15Click(Sender: TObject);

begin

StatusBar1.Panels[0].Text := ‘недозволено !!!’;

Memo1.Lines.Add(‘В стеке недозволено ворачиваться в начало т.к. указатель показывает сходу на начало;’);

end;

procedure TForm1.Button16Click(Sender: TObject);

var

i: Integer;

s: string;

begin

StatusBar1.Panels[0].Text := »;

GetStack(Stack);

if Stack <> nil then

begin

while Edit4.Text[StackPos] <> ‘ ‘ do Inc(StackPos);

Inc(StackPos);

s := Edit4.Text;

for i := 1 to StackPos — 1 do

if s[i] <> ‘ ‘ then s[i] := ‘ ‘;

Edit4.Text := s;

end

else

begin

ShowMessage(‘Стек пуст’);

Edit4.Text := »;

Image4.Hide;

Button14.Enabled := False;

Button15.Enabled := False;

Button16.Enabled := False;

StatusBar1.Panels[1].Text := ‘Стек пуст’;

end;

Image4.Left := Round(StackPos * 7);

end;

procedure TForm1.Button20Click(Sender: TObject);

var

i: Integer;

s: string;

begin

StatusBar1.Panels[0].Text := »;

GetDeckBegin(DeckBegin);

if DeckBegin <> nil then

begin

while Edit5.Text[DeckBeginPos] <> ‘ ‘ do Inc(DeckBeginPos);

Inc(DeckBeginPos);

s := Edit5.Text;

for i := 1 to DeckBeginPos — 1 do

if s[i] <> ‘ ‘ then s[i] := ‘ ‘;

Edit5.Text := s;

end;

if (DeckBegin = nil) and (DeckBegin = DeckEnd) then

begin

ShowMessage(‘Дек пуст’);

Edit5.Text := »;

Image5.Hide;

Image6.Hide;

Button18.Enabled := False;

Button19.Enabled := False;

Button20.Enabled := False;

StatusBar1.Panels[1].Text := ‘Дек пуст’;

end;

Image5.Left := Round(DeckBeginPos * 7);

end;

procedure TForm1.FormCreate(Sender: TObject);

begin

Windows.SetFocus(Button21.Handle);

end;

procedure TForm1.Button19Click(Sender: TObject);

var

i, a: Integer;

s: string;

begin

StatusBar1.Panels[0].Text := »;

GetDeckEnd(DeckEnd);

if DeckEnd <> nil then

begin

while Edit5.Text[DeckEndPos] <> ‘ ‘ do Dec(DeckEndPos);

Dec(DeckEndPos);

s := Edit5.Text;

for i := DeckEndPosition downto DeckEndPos + 1 do

if s[i] <> ‘ ‘ then s[i] := ‘ ‘;

Edit5.Text := s;

//удаляем все пробелы конце строчки

s := »;

i := Length(Edit5.Text) — 1;

while Edit5.Text[i] = ‘ ‘ do Dec(i);

for a := 1 to i do s := s + Edit5.Text[a];

Edit5.Text := s;

end;

if (DeckEnd = nil) and (DeckBegin = DeckEnd) then

begin

ShowMessage(‘Дек пуст’);

Edit5.Text := »;

Image5.Hide;

Image6.Hide;

Button19.Enabled := False;

Button20.Enabled := False;

StatusBar1.Panels[1].Text := ‘Дек пуст’;

end;

Image6.Left := Round(DeckEndPos * 7 — 9);

end;

procedure TForm1.Button5Click(Sender: TObject);

begin

Form5.Show;

end;

procedure TForm1.Button2Click(Sender: TObject);

begin

DeleteFromList(ListPos);

DoNewEditList;

end;

procedure TForm1.Button6Click(Sender: TObject);

begin

DeleteFromListTwo(ListTwoPos);

DoNewEditListTwo;

end;

procedure TForm1.Button10Click(Sender: TObject);

var

i, a: Integer;

s1, s2: string;

begin

GetQueue(QueueBegin);

if QueueBegin <> nil then

begin

i := QueuePos;

while (Edit3.Text[i] <> ‘ ‘) and (i <= Length(Edit3.Text)) do Inc(i);

Inc(i);

s1 := »;

s2 := »;

for a := 1 to QueuePos — 1 do s1 := s1 + Edit3.Text[a];

for a := i to Length(Edit3.Text) do s2 := s2 + Edit3.Text[a];

Edit3.Text := s1 + s2;

end;

procedure TForm1.Button9Click(Sender: TObject);

begin

Form4.Show;

end;

procedure TForm1.Button14Click(Sender: TObject);

var

i, a: Integer;

s1, s2: string;

begin

GetStack(Stack);

i := StackPos;

while (Edit4.Text[i] <> ‘ ‘) and (i <= Length(Edit4.Text)) do Inc(i);

Inc(i);

s1 := »;

s2 := »;

for a := 1 to StackPos — 1 do s1 := s1 + Edit4.Text[a];

for a := i to Length(Edit4.Text) do s2 := s2 + Edit4.Text[a];

Edit4.Text := s1 + s2;

end;

procedure TForm1.Button13Click(Sender: TObject);

begin

Form6.Show;

end;

procedure TForm1.Button17Click(Sender: TObject);

begin

Form7.Show;

end;

procedure TForm1.Button18Click(Sender: TObject);

begin

Form8.Show;

end;

procedure TForm1.Button26Click(Sender: TObject);

begin

StatusBar1.Panels[0].Text := ‘недозволено !!!’;

Memo1.Lines.Add(‘В цикл. перечне недозволено передвигаться вспять, т.к. на самом деле цикл. перечень это однонаправ. перечень и как следует связь существует лишь в одну сторону;’);

end;

procedure TForm1.Button25Click(Sender: TObject);

var

qRoundList: List;

i, j: Integer;

Count: Integer;

begin

StatusBar1.Panels[0].Text := »;

qRoundList := RoundList^.Next;

// Подсчет кол-ва елементов в перечне

Count := 1;

while qRoundList <> RoundList do

begin

Inc(Count);

qRoundList := qRoundList^.Next;

end;

qRoundList := RoundList;

i := 0;

while i <> RoundListPos do

begin

qRoundList := qRoundList^.Next;

Inc(i);

end;

if qRoundList <> nil then

begin

if qRoundList^.Next <> nil then Inc(RoundListPos);

if RoundListPos > Count — 1 then RoundListPos := 0;

i := 0;

j := 0;

while i < RoundListPos do

begin

Inc(j);

if Edit7.Text[j] = ‘ ‘ then Inc(i);

end;

if RoundListPos = 0 then j := -1;

Image7.Left := Round(9 + (j + 1) * 7.5);

end;

procedure TForm1.Button23Click(Sender: TObject);

begin

Form9.Show;

end;

procedure TForm1.Button24Click(Sender: TObject);

begin

if RoundList <> nil then

begin

DeleteFromRoundList(RoundListPos);

if RoundList <> nil then DoNewEditRoundList;

end

else

begin

Edit7.Text := »;

ShowMessage(‘Повторяющийся перечень пуст’);

Button24.Enabled := False;

Button25.Enabled := False;

Button26.Enabled := False;

Image7.Hide;

end;

procedure TForm1.N2Click(Sender: TObject);

begin

Close;

end;

procedure TForm1.N5Click(Sender: TObject);

begin

AboutBox.Visible := True;

end;

procedure TForm1.N4Click(Sender: TObject);

begin

Form10.Visible := True;

end;

procedure TForm1.Button27Click(Sender: TObject);

begin

Form11.Show;

end;

procedure TForm1.Button30Click(Sender: TObject);

begin

Form12.Show;

end;

procedure TForm1.Button29Click(Sender: TObject);

begin

Form13.Show;

end;

procedure TForm1.Button31Click(Sender: TObject);

begin

Form14.Show;

end;

procedure TForm1.Button32Click(Sender: TObject);

begin

Form15.Show;

end;

procedure TForm1.N8Click(Sender: TObject);

begin

Form1.Hide;

Form16.Show;

N8.Enabled := False;

end;

procedure TForm1.N11Click(Sender: TObject);

begin

Memo1.Clear;

Memo1.Lines.Add(‘ Лабораторная работа №1.’);

Memo1.Lines.Add(‘ «Списки»‘);

Memo1.Lines.Add(‘______________________________________________________________’);

Memo1.Lines.Add(‘1. Нажмите клавишу «Теория» для получения инфы о перечнях.’);

Memo1.Lines.Add(‘ Пристально изучите теоретический материал.’);

Memo1.Lines.Add(»);

Memo1.Lines.Add(‘2. На листе формата А4, опишите ход проделанной работы.’);

Memo1.Lines.Add(‘ Ответьте на поставленные вопросцы.’);

Memo1.Lines.Add(‘ 1) Что такое линейный перечень?’);

Memo1.Lines.Add(‘ 2) Какие операции можно выполнить с линейным перечнем?’);

Memo1.Lines.Add(‘ 3) Какие существую еще списки?’);

Memo1.Lines.Add(‘ 4) Что представляет из себя связанное распределение?’);

Memo1.Lines.Add(‘ 5) Чем различается связанное распределение от поочередного?’);

Memo1.Lines.Add(‘ 6) Что такое динамические переменные? Функции new и nil.’);

end;

procedure TForm1.Button33Click(Sender: TObject);

begin

Form17.Show;

end;

procedure TForm1.N21Click(Sender: TObject);

begin

Memo1.Clear;

Memo1.Lines.Add(‘ Лабораторная работа №2.’);

Memo1.Lines.Add(‘ «Однонаправленный и двунаправленный перечень»‘);

Memo1.Lines.Add(‘______________________________________________________________’);

Memo1.Lines.Add(‘1. Нажмите клавишу «Теория» для однонаправленного и ‘);

Memo1.Lines.Add(‘ двунаправленного перечня.’);

Memo1.Lines.Add(‘ Пристально изучите теоретический материал.’);

Memo1.Lines.Add(»);

Memo1.Lines.Add(‘2. Нажмите клавишу «Обновить» для формирования списков.’);

Memo1.Lines.Add(‘ Клавиши «<< и >>» служат для перемещения курсора по списку.’);

Memo1.Lines.Add(‘ а) Переместитесь на лево до 3, 5 и крайнего элемента;’);

Memo1.Lines.Add(‘ б) Переместитесь на Право до первого элемента (см. коментарии);’);

Memo1.Lines.Add(‘ Клавиша «Добавить» служит для прибавления элемента в перечень.’);

Memo1.Lines.Add(‘ а) Добавьте опосля 3, 5, 7 элемента цифру 33 в обоих перечнях;’);

Memo1.Lines.Add(‘ б) Добавте 1-м и 3-м элементом цифру 55 в двунаправленном перечне;’);

Memo1.Lines.Add(‘ Клавиша «Удалить» служит для удаления элемента из перечня.’);

Memo1.Lines.Add(‘ а) Удалите 3, 5, 7 элементы в однонаправленном перечне;’);

Memo1.Lines.Add(‘ б) Удалите крайний, 1 и 3 элементы в двунаправленном;’);

Memo1.Lines.Add(»);

Memo1.Lines.Add(‘3. На листе формата А4, опишите ход проделанной работы.’);

Memo1.Lines.Add(‘ Ответьте на поставленные вопросцы:’);

Memo1.Lines.Add(‘ 1) Обратите внимание как {перемещается} курсор?’);

Memo1.Lines.Add(‘ 2) Чем различается однонаправленный и двунаправленный списки?’);

Memo1.Lines.Add(‘ 3) Можно ли добавить элемент в хоть какое пространство перечня?’);

Memo1.Lines.Add(‘ 4) Можно ли удалить хоть какой элемент из перечня?’);

end;

procedure TForm1.N31Click(Sender: TObject);

begin

Memo1.Clear;

Memo1.Lines.Add(‘ Лабораторная работа №3.’);

Memo1.Lines.Add(‘ «Повторяющийся перечень»‘);

Memo1.Lines.Add(‘______________________________________________________________’);

Memo1.Lines.Add(‘1. Нажмите клавишу «Теория» для повторяющегося перечня?’);

Memo1.Lines.Add(‘ Пристально изучите теоретический материал.’);

Memo1.Lines.Add(»);

Memo1.Lines.Add(‘2. Нажмите клавишу «Обновить» для формирования списков.’);

Memo1.Lines.Add(‘ Клавиши «<< и >>» служат для перемещения курсора по списку.’);

Memo1.Lines.Add(‘ а) Переместитесь на Право до 3, 5, крайнего, первого элемента;’);

Memo1.Lines.Add(‘ б) Переместитесь на лево (см. коментарии);’);

Memo1.Lines.Add(‘ Клавиша «Добавить» служит для прибавления элемента в перечень.’);

Memo1.Lines.Add(‘ а) Добавьте 3, 5, 1-м элементами число 44;’);

Memo1.Lines.Add(‘ б) Добавьте опосля 2, 4, 1-го элемента число 0;’);

Memo1.Lines.Add(‘ Клавиша «Удалить» служит для удаления элемента из перечня.’);

Memo1.Lines.Add(‘ Удалите 3, 5, 1, 4 элементы;’);

Memo1.Lines.Add(»);

Memo1.Lines.Add(‘3. На листе формата А4, опишите ход проделанной работы.’);

Memo1.Lines.Add(‘ Ответьте на поставленные вопросцы:’);

Memo1.Lines.Add(‘ 1) Обратите внимание как {перемещается} курсор?’);

Memo1.Lines.Add(‘ 2) Какую ссылку имеет крайний элемент повторяющегося перечня?’);

Memo1.Lines.Add(‘ 3) Что именуется головой и хвостом перечня?’);

end;

procedure TForm1.N41Click(Sender: TObject);

begin

Memo1.Clear;

Memo1.Lines.Add(‘ Лабораторная работа №4.’);

Memo1.Lines.Add(‘ «Очередь»‘);

Memo1.Lines.Add(‘______________________________________________________________’);

Memo1.Lines.Add(‘1. Нажмите клавишу «Теория» для очереди.’);

Memo1.Lines.Add(‘ Пристально изучите теоретический материал.’);

Memo1.Lines.Add(»);

Memo1.Lines.Add(‘2. Нажмите клавишу «Обновить» для формирования списков.’);

Memo1.Lines.Add(‘ Клавиши «<< и >>» служат для перемещения курсора по очереди.’);

Memo1.Lines.Add(‘ а) Переместитесь на Право до 3 элемента;’);

Memo1.Lines.Add(‘ б) Переместитесь на лево (см. коментарии);’);

Memo1.Lines.Add(‘ Клавиша «Добавить» служит для прибавления элемента в очередь.’);

Memo1.Lines.Add(‘ а) Добавьте 1, 4, 5-м элементами число 99;’);

Memo1.Lines.Add(‘ б) Добавьте крайним число 999;’);

Memo1.Lines.Add(‘ Клавиша «Удалить» служит для удаления элемента из очереди.’);

Memo1.Lines.Add(‘ Удалите 1, 2, 3 элементы;’);

Memo1.Lines.Add(»);

Memo1.Lines.Add(‘3. На листе формата А4, опишите ход проделанной работы.’);

Memo1.Lines.Add(‘ Ответьте на поставленные вопросцы:’);

Memo1.Lines.Add(‘ 1) Как удаляется и добавляется элементы в очереди?’);

Memo1.Lines.Add(‘ 2) В чем различие и сходство очереди и однонаправленного перечня?’);

Memo1.Lines.Add(‘ 3) Что именуется головой и хвостом очереди?’);

Memo1.Lines.Add(‘ 4) Как размещаются элементы в очереди?’);

end;

procedure TForm1.N51Click(Sender: TObject);

begin

Memo1.Clear;

Memo1.Lines.Add(‘ Лабораторная работа №5.’);

Memo1.Lines.Add(‘ «Стек»‘);

Memo1.Lines.Add(‘______________________________________________________________’);

Memo1.Lines.Add(‘1. Нажмите клавишу «Теория» для стека.’);

Memo1.Lines.Add(‘ Пристально изучите теоретический материал.’);

Memo1.Lines.Add(»);

Memo1.Lines.Add(‘2. Нажмите клавишу «Обновить» для формирования списков.’);

Memo1.Lines.Add(‘ Клавиши «<< и >>» служат для перемещения курсора в стеке.’);

Memo1.Lines.Add(‘ а) Переместитесь на Право до 4 элемента;’);

Memo1.Lines.Add(‘ б) Переместитесь на лево (см. коментарии);’);

Memo1.Lines.Add(‘ Клавиша «Добавить» служит для прибавления элемента в стек.’);

Memo1.Lines.Add(‘ Добавьте 1, 3, 5 элементами число 22;’);

Memo1.Lines.Add(‘ Клавиша «Удалить» служит для удаления элемента из стека.’);

Memo1.Lines.Add(‘ Удалите 1, 3, 5, крайний элементы;’);

Memo1.Lines.Add(‘3. На листе формата А4, опишите ход проделанной работы.’);

Memo1.Lines.Add(‘ Ответьте на поставленные вопросцы:’);

Memo1.Lines.Add(‘ 1) Как удаляется и добавляется элементы в стек?’);

Memo1.Lines.Add(‘ 2) Приведи примеры стека на практике?’);

end;

procedure TForm1.N61Click(Sender: TObject);

begin

Memo1.Clear;

Memo1.Lines.Add(‘ Лабораторная работа №6.’);

Memo1.Lines.Add(‘ «Дек»‘);

Memo1.Lines.Add(‘______________________________________________________________’);

Memo1.Lines.Add(‘1. Нажмите клавишу «Теория» для дека.’);

Memo1.Lines.Add(‘ Пристально изучите теоретический материал.’);

Memo1.Lines.Add(»);

Memo1.Lines.Add(‘2. Нажмите клавишу «Обновить» для формирования списков.’);

Memo1.Lines.Add(‘ Клавиши «<< и >>» служат для перемещения курсора в деке.’);

Memo1.Lines.Add(‘ а) Переместитесь на лево на 2 элемента;’);

Memo1.Lines.Add(‘ б Переместитесь на Право на 4 элемента;’);

Memo1.Lines.Add(‘ Клавиша «Добавить» служит для прибавления элемента в дек.’);

Memo1.Lines.Add(‘ а) Добавьте 1, 3 элементом число 11;’);

Memo1.Lines.Add(‘ б) Добавьте 5, 6 элементом число 88;’);

Memo1.Lines.Add(‘ Клавиша «Удалить» служит для удаления элемента из дека.’);

Memo1.Lines.Add(‘ а) Удалите 2, 4 элементы;’);

Memo1.Lines.Add(‘ б) Добавте 6, 7 элементы;’);

Memo1.Lines.Add(»);

Memo1.Lines.Add(‘3. На листе формата А4, опишите ход проделанной работы.’);

Memo1.Lines.Add(‘ Ответьте на поставленные вопросцы:’);

Memo1.Lines.Add(‘ 1) Как удаляется и добавляется элементы в дек?’);

Memo1.Lines.Add(‘ 2) В чем сходны и различны дек, стек и двунаправленный перечень?’);

end;

procedure TForm1.N71Click(Sender: TObject);

begin

Memo1.Clear;

Memo1.Lines.Add(‘ Лабораторная работа №7.’);

Memo1.Lines.Add(‘ «тест«‘);

Memo1.Lines.Add(‘______________________________________________________________’);

Memo1.Lines.Add(‘1. Повторите весь теоретический материал.’);

Memo1.Lines.Add(»);

Memo1.Lines.Add(‘2. Поработайте с демонстрационной программкой.’);

Memo1.Lines.Add(»);

Memo1.Lines.Add(‘3. Запустите тест (сервистест либо Ctrl + T).’);

Memo1.Lines.Add(‘ Ответьте на поставленные вопросцы теста.’);

Memo1.Lines.Add(»);

Memo1.Lines.Add(‘4. Результаты теста сказать педагогу.’);

end;

procedure TForm1.N9Click(Sender: TObject);

begin

Form18.Show;

end;

end.

unit Unit2; //
Формирование списков

interface

uses SysUtils, Windows, Dialogs;

type

List = ^Spisok; //Однонаправленный

Spisok = record

Info: Integer;

Next: List;

end;

ListTwo = ^SpisokTwo; //Двунаправленный

SpisokTwo = record

Info: Integer;

Next: ListTwo;

Prev: ListTwo;

end;

procedure CreateLists;

procedure AddToList(X: Integer; var PointerEndList: List);

procedure AddToListAfterPos(X: Integer; Position: Integer);

procedure DeleteFromList(Position: Integer);

procedure AddToListTwo(X: Integer; var PointerEndListTwo: ListTwo);

procedure AddToListTwoAfterPos(X: Integer; Position: Integer);

procedure DeleteFromListTwo(Position: Integer);

procedure AddToQueue(X: Integer; var PointerEndQueue: List);

procedure AddToEndQueue(X: Integer);

function GetQueue(var PointerBegin: List): Integer;

procedure AddToStack(X: Integer; var PointerStack: List);

function GetStack(var PointerStack: List): Integer;

procedure AddToDeck(X: Integer;

var PointerDeckBegin, PointerDeckEnd: ListTwo; Flag: Integer);

function GetDeckBegin(var PointerDeckBegin: ListTwo): Integer;

function GetDeckEnd(var PointerDeckEnd: ListTwo): Integer;

procedure DestroyList(PointerBegin: List);

procedure DestroyListTwo(PointerBegin: ListTwo);

procedure AddToRoundList(X: Integer; var PointerRoundList: List);

procedure DeleteFromRoundList(Position: Integer);

procedure DestroyRoundList(var PointerRoundList: List);

implementation

uses Unit1;

procedure DestroyList(PointerBegin: List);

var

q: List;

begin

while PointerBegin <> nil do

begin

q := PointerBegin;

PointerBegin := PointerBegin^.Next;

if q <> nil then Dispose(q);

end;

procedure DestroyListTwo(PointerBegin: ListTwo);

var

q: ListTwo;

begin

while PointerBegin <> nil do

begin

q := PointerBegin;

PointerBegin := PointerBegin^.Next;

if q <> nil then Dispose(q);

end;

procedure DestroyRoundList(var PointerRoundList: List);

var

q, t: List;

begin

q := PointerRoundList^.Next;

PointerRoundList^.Next := nil;

while q <> nil do

begin

t := q;

q := q^.Next;

if t <> nil then Dispose(t);

end;

PointerRoundList := nil;

end;

procedure AddToList(X: Integer; var PointerEndList: List); //Добавить элемент в

//конец перечня (PointerEnd — указатель на крайний элемент перечня)

begin

ifPointerEndList = nilthen // Если 1-ый элемент еще не существует

begin

New(PointerEndList);

PointerEndList^.Info := X;

PointerEndList^.Next := nil;

end

else

begin

New(PointerEndList^.Next);

PointerEndList := PointerEndList^.Next;

PointerEndList^.Info := X;

PointerEndList^.Next := nil;

end;

procedure AddToListAfterPos(X: Integer; Position: Integer);

var //Добавить элемент в перечень опосля Position

i: Integer;

q, qNew: List;

begin

ifPosition = 0 then // Если позиция = 0, то добавляем в начало

begin

New(qNew);

qNew^.Info := X;

qNew^.Next := ListBegin;

ListBegin := qNew;

end

else

begin

q := ListBegin;

i := 0;

while (i < Position) and (q <> nil) do // Отыскиваем элемент опосля которого

// необходимо вставить

begin

q := q^.Next;

Inc(i);

end;

ifq <> nilthen // Если элемент существует то вставляем

begin

New(qNew);

qNew^.Info := X;

qNew^.Next := q^.Next;

q^.Next := qNew;

end

elseShowMessage(‘Элемент, опосля которого желаете вставить, удален’);

end;

procedure AddToRoundList(X: Integer; var PointerRoundList: List);

var qRound: List;

begin

if PointerRoundList = nil then

begin

New(PointerRoundList);

PointerRoundList^.Info := X;

PointerRoundList^.Next := PointerRoundList;

RoundList := PointerRoundList;

end

else

begin

New(qRound);

qRound^.Info := X;

qRound^.Next := PointerRoundList^.Next;

PointerRoundList^.Next := qRound;

end;

PointerRoundList := PointerRoundList^.Next;

end;

procedure DeleteFromRoundList(Position: Integer);

var

q, h: List;

i: Integer;

begin

if RoundList^.Next = RoundList then //один элемент в перечне

begin

if RoundList <> nil then Dispose(RoundList);

RoundList := nil;

end

else // не один элемент в перечне

begin

i := 1;

q := RoundList;

while i < RoundListPos do

begin

Inc(i);

q := q^.Next;

end;

if i <> 1 then

begin

h := q^.Next;

q^.Next := h^.Next;

if h <> nil then Dispose(h);

end

else

begin

q := RoundList^.Next;

while q^.Next <> RoundList do q := q^.Next;

h := q^.Next;

q^.Next := h^.Next;

if h <> nil then Dispose(h);

RoundList := q^.Next;

end;

if RoundList <> nil then

begin

q := RoundList^.Next;

i := 1;

while q <> RoundList do

begin

Inc(i);

q := q^.Next;

end;

if i = RoundListPos then

begin

RoundListPos := 0;

Form1.Image7.Left := 9;

end;

procedure DeleteFromList(Position: Integer); //Удаляет элемент под

//номером Position

var

i: Integer;

q, r: List;

begin

q := ListBegin;

ifq <> nilthen // Если перечень не пуст, то

begin

ifPosition = 0 then //Если позиция = 0, то удаляем 1-ый элемент

begin

ListBegin := q^.Next;

if q <> nil then Dispose(q);

end

else

begin

i := 0;

while (i < Position — 1) and (q <> nil) do //Отыскиваем элемент опосля

//которого необходимо удалить

begin

q := q^.Next;

Inc(i);

end;

r := q^.Next;

ifr <> nilthen //Если удаляемый элемент существует, то удаляем его

begin

q^.Next := r^.Next;

if r <> nil then Dispose(r);

end

elseShowMessage(‘Элемент уже не существует’);

end;

end

else

begin

ShowMessage(‘Перечень пуст’);

Form1.Image1.Hide;

end;

procedure AddToListTwo(X: Integer; var PointerEndListTwo: ListTwo); //Добавить элемент в

//конец дв-списка (PointerEnd — указатель на крайний элемент перечня)

begin

ifPointerEndListTwo = nilthen //Если перечень еще не существует либо пуст,

//добавляем в начало

begin

New(PointerEndListTwo);

PointerEndListTwo^.Info := X;

PointerEndListTwo^.Next := nil;

PointerEndListTwo^.Prev := nil;

end

else

begin

New(PointerEndListTwo^.Next);

PointerEndListTwo := PointerEndListTwo^.Next;

PointerEndListTwo^.Info := X;

PointerEndListTwo^.Next := nil;

PointerEndListTwo^.Prev := nil;

end;

procedure AddToListTwoAfterPos(X: Integer; Position: Integer);

var //Добавить элемент в двунап. перечень опосля Position

i: Integer;

q, qNew: ListTwo;

begin

ifPosition = 0 then //Если позиция = 0, вставляем в начало

begin

New(qNew);

qNew^.Info := X;

qNew^.Next := ListTwoBegin;

ListTwoBegin := qNew;

end

else

begin

q := ListTwoBegin;

i := 0;

while (i < Position) and (q <> nil) do //Отыскиваем элемент опосля которого

//необходимо вставить

begin

q := q^.Next;

Inc(i);

end;

ifq <> nilthen // Если элемент существует то вставляем

begin

New(qNew);

qNew^.Info := X;

qNew^.Next := q^.Next;

qNew^.Prev := q;

q^.Next := qNew;

end

elseShowMessage(‘Элемент, опосля которого желаете вставить, удален’);

end;

procedure DeleteFromListTwo(Position: Integer); //Удаляет элемент

//под номером Position

var

i: Integer;

q, r: ListTwo;

begin

q := ListTwoBegin;

ifq <> nilthen //Если удаляемый элемент существует, то

begin

ifPosition = 0 then //Если позиция = 0, то удаляем 1-ый элемент

begin

ListTwoBegin^.Prev := nil;

ListTwoBegin := q^.Next;

if q <> nil then Dispose(q);

end

else

begin

i := 0;

while (i < Position — 1) and (q <> nil) do //Отыскиваем элемент

// опосля которого необходимо удалить

begin

q := q^.Next;

Inc(i);

end;

r := q^.Next;

ifr <> nilthen //Если он существует, то удаляем его

begin

if r^.Next <> nil then r^.Next^.Prev := q;

q^.Next := r^.Next;

if r <> nil then Dispose(r);

end

elseShowMessage(‘Элемент уже не существует’);

end;

end

else

begin

ShowMessage(‘Перечень пуст’);

Form1.Image2.Hide;

end;

procedure AddToQueue(X: Integer; var PointerEndQueue: List); //Добавить элемент

//в конец очереди (PointerEnd — указатель на крайний элемент очереди)

begin

ifPointerEndQueue = nilthen //Если очередь еще не существует либо пуста

//добавляем в начало

begin

New(PointerEndQueue);

PointerEndQueue^.Info := X;

PointerEndQueue^.Next := nil;

end

else

begin

New(PointerEndQueue^.Next);

PointerEndQueue := PointerEndQueue^.Next;

PointerEndQueue^.Info := X;

PointerEndQueue^.Next := nil;

end;

function GetQueue(var PointerBegin: List): Integer; //ф-ия получает элемент из

// очереди и возвращает указатель на начало очереди

var

rQueue: List;

begin

rQueue := PointerBegin;

ifrQueue <> nilthen //Если очередь не пуста

begin

PointerBegin := PointerBegin^.Next;

Result := rQueue^.Info;

if rQueue <> nil then Dispose(rQueue);

end

else

begin

ShowMessage(‘Очередь пуста’);

Form1.Edit3.Text := »;

Form1.Button10.Enabled := False;

Form1.Button11.Enabled := False;

Form1.Button12.Enabled := False;

Form1.Image3.Hide;

end;

procedure AddToEndQueue(X: Integer);

var

Info: Integer;

rQueue, qQueue: List;

FlagList: Boolean;

begin

FlagList := True; //Для выделения первого элемента

qQueue := nil;

rQueue := nil;

whileQueueBegin <> nildo //Отыскиваем указатель на крайний элемент очереди

begin

Info := GetQueue(QueueBegin);

AddToQueue(Info, rQueue); //Формируем новейшую очередь из частей старенькой

//очереди, чтоб не утратить ее

if FlagList then /////////////////////////////////////

begin // //

qQueue := rQueue; // формируем указатель на очередь //

FlagList := False; // //

end; // //////////////////////////////////

end;

AddToQueue(X, rQueue);

if qQueue <> nil then QueueBegin := qQueue // определяем указатель на очередь

else QueueBegin := rQueue; //////////////////////////////////

end;

procedure AddToStack(X: Integer; var PointerStack: List); //Добавить элемент в

//стек (PointerStack — указатель на стек)

var

Stacks: List;

begin

if PointerStack = nil then //Если стек пуст, то формируем его

begin

New(PointerStack);

PointerStack^.Info := X;

PointerStack^.Next := nil;

end

else //по другому добавляем элемент

begin

New(Stacks);

Stacks^.Info := X;

Stacks^.Next := PointerStack;

PointerStack := Stacks;

end;

function GetStack(var PointerStack: List): Integer; //ф-ия получает элемент из

// стека и возвращает указатель на стек

var

rStack: List;

begin

rStack := PointerStack;

ifrStack <> nilthen //Если стек еще не пуст

begin

PointerStack := PointerStack^.Next;

Result := rStack^.Info;

if rStack <> nil then Dispose(rStack);

end

else

begin

ShowMessage(‘Стек пуст’);

Form1.Button14.Enabled := False;

Form1.Image4.Hide;

end;

procedure AddToDeck(X: Integer; var PointerDeckBegin, PointerDeckEnd: ListTwo;

Flag: Integer); //Добавить элемент в дек

//PointerDeckBegin — указатель на начало дека

//PointerDeckEnd — указатель на конец дека

var

Decks: ListTwo;

begin

if PointerDeckBegin = nil then //Если дек пуст, то формируем его

begin

New(PointerDeckBegin);

PointerDeckBegin^.Info := X;

PointerDeckBegin^.Next := nil;

PointerDeckBegin^.Prev := nil;

PointerDeckEnd := PointerDeckBegin;

end

else //по другому добавляем элемент

begin

if Flag = 0 then //добавляем в начало

begin

New(Decks);

Decks^.Info := X;

Decks^.Next := PointerDeckBegin;

Decks^.Prev := nil;

PointerDeckBegin^.Prev := Decks;

PointerDeckBegin := Decks;

end

else //добавлям в конец

begin

New(Decks);

Decks^.Info := X;

Decks^.Next := nil;

Decks^.Prev := PointerDeckEnd;

PointerDeckEnd^.Next := Decks;

PointerDeckEnd := Decks;

end;

function GetDeckBegin(var PointerDeckBegin: ListTwo): Integer;

//ф-ия получает элемент из начала дека и возвращает указатель на начало дека.

var

q: ListTwo;

begin

if PointerDeckBegin <> nil then //Если дек не пуст

begin

Result := PointerDeckBegin^.Info;

q := PointerDeckBegin;

PointerDeckBegin := q^.Next;

if PointerDeckBegin <> nil then PointerDeckBegin^.Prev := nil;

if q <> nil then Dispose(q);

end

else

begin

ShowMessage(‘Дек пуст’);

Form1.Edit5.Text := »;

Form1.Button18.Enabled := False;

Form1.Button19.Enabled := False;

Form1.Button20.Enabled := False;

Form1.Image5.Hide;

Form1.Image6.Hide;

end;

function GetDeckEnd(var PointerDeckEnd: ListTwo): Integer;

//ф-ия получает элемент из конца дека и возвращает указатель на конец дека.

var

q: ListTwo;

begin

if PointerDeckEnd <> nil then //Если дек не пуст

begin

Result := PointerDeckEnd^.Info;

q := PointerDeckEnd;

PointerDeckEnd := q^.Prev;

if PointerDeckEnd <> nil then PointerDeckEnd^.Next := nil;

if q <> nil then Dispose(q);

end

else

begin

ShowMessage(‘Дек пуст’);

Form1.Edit5.Text := »;

Form1.Button18.Enabled := False;

Form1.Button19.Enabled := False;

Form1.Button20.Enabled := False;

Form1.Image5.Hide;

Form1.Image6.Hide;

end;

procedure CreateLists; //процедура сотворения всех списков

var

i: Integer;

X: Integer;

Uk, q: List;

UkTwo, qTwo: ListTwo;

UkQueue, qQueue: List;

qStack: List;

qDeckBegin, qDeckEnd: ListTwo;

begin

X := Random(101); //Определяем

Uk := nil; //////////////////////////

q := nil; // //

UkTwo := nil; // НАЧАЛЬНЫЕ УСТАНОВКИ: //

qTwo := nil; // //

UkQueue := nil; // все указатели = nil //

qQueue := nil; // //

qStack := nil; // //

qDeckBegin := nil; // //

qDeckEnd := nil; //////////////////////////

// Destroy for every lists

if ListBegin <> nil then DestroyList(ListBegin);

if ListTwoBegin <> nil then DestroyListTwo(ListTwoBegin);

if QueueBegin <> nil then DestroyList(QueueBegin);

if Stack <> nil then DestroyList(Stack);

if DeckBegin <> nil then DestroyListTwo(DeckBegin);

if RoundList <> nil then DestroyRoundList(RoundList);

AddToList(X, Uk); //

AddToListTwo(X, UkTwo); // Добавляем Х в

AddToQueue(X, UkQueue); // любой перечень

AddToStack(X, qStack); //

AddToDeck(X, qDeckBegin, qDeckEnd, 0); //

AddToRoundList(X, RoundList); ///////////////////

Unit1.Form1.Edit6.Text := IntToStr(X);

q := Uk; //

qTwo := UkTwo; // Формируем указатели на начало списков

qQueue := UkQueue; //

for i := to 9 do //Предстоящее формирование списков

begin

X := Random(101);

AddToList(X, q);

AddToListTwo(X, qTwo);

AddToQueue(X, qQueue);

AddToStack(X, qStack);

AddToDeck(X, qDeckBegin, qDeckEnd, 0);

AddToRoundList(X, RoundList);

Unit1.Form1.Edit6.Text := Unit1.Form1.Edit6.Text + ‘ ‘ + IntToStr(X);

end;

ListBegin := Uk; //////////////////////////////////////

ListTwoBegin := UkTwo; // //

QueueBegin := UkQueue; // //

Stack := qStack; // Определяем указатели все списки //

DeckBegin := qDeckBegin; // //

DeckEnd := qDeckEnd; // //

RoundList := RoundList^.Next //////////////////////////////////

end;

end.

unit Unit16; //
тест

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,

StdCtrls, ExtCtrls;

type

TForm16 = class(TForm)

Memo1: TMemo;

Panel1: TPanel;

Button1: TButton;

RadioGroup1: TRadioGroup;

Button2: TButton;

procedure RadioGroup1Click(Sender: TObject);

procedure Button2Click(Sender: TObject);

procedure Button1Click(Sender: TObject);

procedure FormClose(Sender: TObject; var Action: TCloseAction);

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form16: TForm16;

NumberQuestion: Integer = 0;

NumberTrueAnswer: Integer = 0;

ff: Boolean = True;

implementation

uses Unit1, Un18_Lab;

{$R *.DFM}

procedure TForm16.RadioGroup1Click(Sender: TObject);

begin

Button1.Enabled := True;

Button1.SetFocus;

end;

procedure TForm16.Button2Click(Sender: TObject);

begin

Form16.Hide;

Form1.Show;

end;

procedure TForm16.Button1Click(Sender: TObject);

begin

Memo1.Lines.Clear;

Button1.Enabled := False;

Inc(NumberQuestion);

case NumberQuestion of

begin

if RadioGroup1.ItemIndex = 0 then Inc(NumberTrueAnswer);

Memo1.Lines.Add(‘Однонаправленный перечень — это …’);

RadioGroup1.Items.Clear;

RadioGroup1.Items.Add(‘Перечень, элементы которого имеют связь со последующим и предшествующим элементом’);

RadioGroup1.Items.Add(‘Перечень, элементы которого имеют связь со последующим элементом’);

RadioGroup1.Items.Add(‘Перечень, элементы которого не имеют связи’);

end;

begin

if RadioGroup1.ItemIndex = 1 then Inc(NumberTrueAnswer);

Memo1.Lines.Add(‘Если элемент содержит ссылки на последующий и предшествующий элемент, то это …’);

RadioGroup1.Items.Clear;

RadioGroup1.Items.Add(‘однонаправленный перечень’);

RadioGroup1.Items.Add(‘двунаправленный перечень’);

RadioGroup1.Items.Add(‘очередь’);

RadioGroup1.Items.Add(‘стек’);

RadioGroup1.Items.Add(‘дек’);

RadioGroup1.Items.Add(‘повторяющийся перечень’);

end;

begin

if RadioGroup1.ItemIndex = 1 then Inc(NumberTrueAnswer);

Memo1.Lines.Add(‘Куда добавляется элемент в двунаправленный перечень?’);

RadioGroup1.Items.Clear;

RadioGroup1.Items.Add(‘В начало’);

RadioGroup1.Items.Add(‘В конец’);

RadioGroup1.Items.Add(‘В хоть какое другое пространство‘);

end;

begin

if RadioGroup1.ItemIndex = 2 then Inc(NumberTrueAnswer);

Memo1.Lines.Add(‘Чем различается однонаправленный перечень от двунаправленного?’);

RadioGroup1.Items.Clear;

RadioGroup1.Items.Add(‘Существует связь с предшествующим элементом’);

RadioGroup1.Items.Add(‘Не существует связь с предшествующим элементом’);

RadioGroup1.Items.Add(‘Не различаются’);

end;

begin

if RadioGroup1.ItemIndex = 1 then Inc(NumberTrueAnswer);

Memo1.Lines.Add(‘Какой элемент считывается из стека?’);

RadioGroup1.Items.Clear;

RadioGroup1.Items.Add(‘Крайний’);

RadioGroup1.Items.Add(‘Хоть какой’);

RadioGroup1.Items.Add(‘1-ый’);

end;

begin

if RadioGroup1.ItemIndex = 0 then Inc(NumberTrueAnswer);

Memo1.Lines.Add(‘Чем различается дек от стека?’);

RadioGroup1.Items.Clear;

RadioGroup1.Items.Add(‘Добавление в любом пространство. Удаление из начала’);

RadioGroup1.Items.Add(‘Добавление в начало. Удаление из хоть какого места’);

RadioGroup1.Items.Add(‘Все включения исключения происходят на обоих его концах’);

end;

begin

if RadioGroup1.ItemIndex = 2 then Inc(NumberTrueAnswer);

Memo1.Lines.Add(‘Откуда считывается элемент из очереди?’);

RadioGroup1.Items.Clear;

RadioGroup1.Items.Add(‘С конца’);

RadioGroup1.Items.Add(‘С начала’);

RadioGroup1.Items.Add(‘Из люього места’);

end;

begin

if RadioGroup1.ItemIndex = 1 then Inc(NumberTrueAnswer);

Memo1.Lines.Add(‘Куда добавляется элемент в стек?’);

RadioGroup1.Items.Clear;

RadioGroup1.Items.Add(‘В конец’);

RadioGroup1.Items.Add(‘В начало’);

RadioGroup1.Items.Add(‘В хоть какое пространство‘);

end;

begin

if RadioGroup1.ItemIndex = 0 then Inc(NumberTrueAnswer);

Memo1.Lines.Add(‘Какую ссылку содержит крайний элемент повторяющегося перечня?’);

RadioGroup1.Items.Clear;

RadioGroup1.Items.Add(‘На 1-ый элемент’);

RadioGroup1.Items.Add(‘На предшествующий элемент’);

RadioGroup1.Items.Add(‘NIL’);

end;

10:

begin

if RadioGroup1.ItemIndex = 0 then Inc(NumberTrueAnswer);

Memo1.Lines.Add(‘Если все включения и исключения происходят на одном конце перечня, то это …’);

RadioGroup1.Items.Clear;

RadioGroup1.Items.Add(‘однонаправленный перечень’);

RadioGroup1.Items.Add(‘двунаправленный перечень’);

RadioGroup1.Items.Add(‘очередь’);

RadioGroup1.Items.Add(‘стек’);

RadioGroup1.Items.Add(‘дек’);

RadioGroup1.Items.Add(‘повторяющийся перечень’);

end;

11:

begin

if RadioGroup1.ItemIndex = 3 then Inc(NumberTrueAnswer);

Memo1.Lines.Add(‘Если крайний элемент имеет ссылку на 1-ый элемент, то это …’);

RadioGroup1.Items.Clear;

RadioGroup1.Items.Add(‘однонаправленный перечень’);

RadioGroup1.Items.Add(‘двунаправленный перечень’);

RadioGroup1.Items.Add(‘очередь’);

RadioGroup1.Items.Add(‘стек’);

RadioGroup1.Items.Add(‘дек’);

RadioGroup1.Items.Add(‘повторяющийся перечень’);

end;

12:

begin

if RadioGroup1.ItemIndex = 5 then Inc(NumberTrueAnswer);

Button1.Hide;

if NumberTrueAnswer >= 10 then ShowMessage(‘Ваша оценка — ОТЛИЧНО!’);

if (NumberTrueAnswer >= 8) and (NumberTrueAnswer < 10) then ShowMessage(‘Ваша оценка — ХОРОШО!’);

if (NumberTrueAnswer >= 6) and (NumberTrueAnswer < 8) then ShowMessage(‘Ваша оценка — ТРИ!’);

if NumberTrueAnswer < 6 then

begin

ShowMessage(‘Для тебя совершенно точно необходимо почитать теорию. Твоя оценка — Два!!!’);

ff := False;

end;

Form16.Hide;

Form1.Show;

if not ff then Form18.Show;

end;

procedure TForm16.FormClose(Sender: TObject; var Action: TCloseAction);

begin

Form16.Hide;

Form1.Show;

if not ff then Form18.Show;

end;

end.

]]>

Перейти и растаять в своей любимой социалке

Учебная работа. Реферат: Линейные списки. Стек. Дек. Очередь

Учебная работа. Реферат: Линейные списки. Стек. Дек. Очередь

Как? Вы еще не читали? Ну это зря...