МОСКОВСКИЙ ГОСУДАРСТВЕННЫЙ ИНСТИТУТ
РАДИОТЕХНИКИ, ЭЛЕКТРОНИКИ И АВТОМАТИКИ
(ТЕХНИЧЕСКИЙ УНИВЕРСИТЕТ)
Кафедра «Математическое обеспечение вычислительных систем»
ОТЧЕТ
по лабораторному практикуму
по дисциплине «Структуры и алгоритмы обработки данных»
(часть 1)
Группы: ВСМ-6-05
Студент: Антонов А.Е.
Руководитель: Сыромятников В.П.
Москва- 2007 год

Лабораторная работа №1
«Кольцевые односвязные списки»
Вариант № 1.18
ПОСТАНОВКА ЗАДАЧИ
Сформировать линейный односвязный список (ЛОС) с заданным указателем sag, работающий с типом данных Integer. Составить программу, которая должна из заданного списка удалить первый и последний элементы.
Составить программу, которая:
-   обеспечивает ввод данных типа Integer с клавиатуры;
-   создает линейный односвязный список из введенных данных с клавиатуры;
-   обеспечивает диалог посредством вывода информационных сообщений и вариантов выполнения дальнейших действий;
-   удаляет первый и последний элементы.
-   в данной программе будут реализованы следующие возможности работы с ЛОС:
0 - Выход из программы
1 - Создание ЛОС
2 - Добавление элемента в начало списка
3 - Добавление элемента в середину списка, перед указанным значением
4 - Добавление элемента в середину списка, после указанного значения
5 - Добавление элемента в конец списка
6 - Удаление элемента в начале списка
7 - Удаление элемента ЛОС стоящего перед указанным значением списка
8 - Удаление элемента ЛОС стоящего после указанного значения списка
9 - Удаление определенного элемента в списке
10 - Удаление элемента в конце списка
11 - Удаление первого и последнего элементов ЛОС
12 - Очистка ЛОС
13 - Поиск элемента по его значению
14 - Сортировка элементов ЛОС
15 - Подсчет количества идентичных по содержанию элементов с указанным
ОПИСАНИЕ АЛГОРИТМА РЕШЕНИЯ ЗАДАЧИ
Ввод данных осуществляется в диалоговом режиме.
Пользователь информируется о вариантах работы в данной программе, об особенностях ввода значений в программе.
Далее осуществляется ввод самого списка. Создается линейный односвязный список, с указанием на конец списка (NIL) и по мере ввода данных, ЛОС наполняется, при этом идет сортировка значений элементов по возрастанию.
После ввода необходимого количества элементов и ввода нулевого значения, созданный и отсортированный ЛОС выводиться на экран.
Далее, следуя указаниям программы, пользователь нажимает Enter, для продолжения работы программы, на экран выводиться перечень возможных вариантов работы в данной программе.
После выбора нужного номера операции, в нашем случае (11 - Удалить первый и последний элементы ЛОС) и нажатия на Enter. Происходит удаление первого и последнего элементов ЛОС, с выводом на экран итогового вида ЛОС.

ОПИСАНИЕ ИСПОЛЬЗУЕМЫХ СТРУКТУР ДАННЫХ
Для хранения данных в соответствии с постановкой задачи необходимо в программе создать Линейный Односвязный Список (ЛОС).
Описание типа используемых данных
Type
 chisla = set of '0'..'9';    {множество}
 TE= Integer;                  {описание целочисленного типа}
 WE= String;                  {описание строкового типа}
 PE= ^EL;                      {описание типа указателя}
 EL= Record                            {описание типа - запись}
 inf: TE;                         {информационная часть элемента, тип Integer}
 inf2: WE;                       {информационная часть элемента, тип String}
 next: PE                        {адресная часть элемента}
 End;
Var
 Sag,                               {указатель начала списка}
 q, qq: PE;                      {переменные указателей}
 oper, st, st2: TE;           {переменные целочисленного типа}
 w, stroka: WE;              {переменные строкового типа}
ОПИСАНИЕ ПОЛЬЗОВАТЕЛЬСКОГО ИНТЕРФЕЙСА
Начальный вид окна программы.
Для начала ввода данных в ЛОС, надо определиться с каким типом данных Вы хотели бы работать. После того, как Вы решили с каким типом данных Вы будете дальше работать, Вам нужно ввести номер варианта дальнейшей работы (1 или 2).
Для выполнения условий данной лабораторной, выбираем тип Integer (тип целочисленный) предел его от -32768 до 32767.
Далее, осуществляется ввод самого списка. Создается линейный односвязный список, с указанием на конец списка (NIL) и по мере ввода данных, ЛОС наполняется, при этом идет сортировка значений элементов по возрастанию.
После ввода необходимого количества элементов и ввода нулевого значения, созданный и отсортированный ЛОС выводиться на экран. (Рис.2)
Далее, следуя указаниям программы, пользователь нажимает Enter для продолжения работы программы, и на экран выводиться перечень возможных вариантов работы в данной программе.(Рис.3)
После выбора нужного номера операции, для выполнения условий нашей задачи, выбираем (11 - Удалить первый и последний элементы ЛОС) и нажимаем на Enter. Происходит удаление первого и последнего элементов ЛОС, с выводом на экран итогового вида ЛОС.(Рис.4)
Видно, что с поставленной задачей наша программа справилась. Были удалены первый и последний элементы ЛОС, а потом был выведен итоговый вид ЛОС.
ЛИСТИНГ ПРОГРАММЫ
Type
chisla = set of '0'..'9';     //множество
TE= Integer;              //описание целочисленного типа
WE= String;              //описание строкового типа
PE= ^EL;                   //тип указателя
EL= Record               //описание типа - запись
inf: TE;                      //информационная часть элемента, тип Integer
inf2: WE;                   //информационная часть элемента, тип String
next: PE                    //адресная часть элемента
End;
Var
Sag,                           //указатель, на начало списка
q, qq: PE;                  //переменные указателей
oper, st, st2: TE;       //переменные целочисленного типа
w, stroka: WE;          //переменные строкового типа
Procedure Print(sag: PE);        {вывод ЛОС}
Var
 q: PE;                       //адресная переменная
Begin
 q:= sag^.next;           //запоминаем адрес первого элемента ЛОС
 if q= Nil then            {проверяем ЛОС на пустоту и если он пустой
                                  выводим сообщение о том, что ЛОС пустой
                                  и выводим варианты дальнейшей работы
                                  программы}
begin
WriteLn(rus('ЛОС пустой, выводить нечего!'));
WriteLn('');
WriteLn(rus('___________________________________________'));
WriteLn(rus('Что Вы хотите сделать?'));
WriteLn(rus(''));
WriteLn(rus('1 - Создать ЛОС'));
WriteLn(rus(''));
WriteLn(rus('0 - Выйти'));
WriteLn(rus(''));
WriteLn(rus('Введите номер требуемой операции '));
WriteLn(rus('___________________________________________'));
WriteLn('');
end
 Else                          {если ЛОС не пустой продолжаем выполнение
                                  процедуры}
Begin                         {проверяем, с каким типом данных происходит
                                  работа программы}
If st = 1 then              {если пользователь выбрал вариант работы, работа с типом Integer}
                                  //st = 1 – работа с типом данных, Integer
Begin
While q<>Nil do       {проходим по всему ЛОС пока не дойдем до указателя конца списка (Nil)}
Begin
Write('[',q^.inf,'] ');    {выводим на экран значение элемента ЛОС – тип
                                  Integer}
q:=q^.next;                //запоминаем адрес следующего элемента
End;
WriteLn;
end
else
Begin
While q<>Nil do       {проходим по всему ЛОС пока не дойдем до
                                  указателя конца списка (Nil)}
Begin
Write('[',q^.inf2,'] ');  {выводим на экран значение элемента ЛОС - тип
                                  String}
q:=q^.next;                //запоминаем адрес следующего элемента
End;
WriteLn(' ');
end;
End;
End;
Procedure Proverka (var w: WE);     {проверка превышения
                                                 значения типа Integer}
Var
                                  a, i: TE;
                                  c: char;
                                  b: chisla;
Begin
w:= '';
ReadLn(w);                               //ввод числа с клавиатуры – тип String
While (w = '') or (w='-')do                 {проверяем, если пользователь не ввел данные или ввел только знак минуса выводим на экран сообщения о не корректные вводе}
Begin
WriteLn(Rus('Вы не ввели данные или они не корректны, попробуйте еще раз')); WriteLn(' ');
Proverka(w);                            //выполняем рекурсивный вход в процедуру
End;
for i:= 1 to length(w) do                    {запускаем цикл проверки числа на корректность ввода, число введено, как строка. По этому мы можем поэлементно проверить каждую цифру}
begin
b:= ['0','1','2','3','4','5','6','7','8','9'];   //множество состоящее из цифр
c:=w[i];                                     {берем каждую цифру из числа проходя от первой до последней}
if (c in b) or (c='-') and (i=1) then      {сравниваем есть ли цифра из введенного числа во множестве заданных цифр и проверяем какое число было введено, отрицательное или положительное и не стоит ли знак минус в середине числа}
else
a:= 1;                                        {если число не корректно делаем пометку для дальнейшей проверки}
end;
if a = 1 then                              {если число не прошло проверку выводим
                                                          сообщение о не корректном вводе числа}
begin
WriteLn(rus('Вы ввели не корректные данные !'));
WriteLn(' ');
Proverka(w);                            {выполняем рекурсивный вход в
                                                          процедуру}
end;
if (length(w)<5) then                 {если длина числа меньше 5 знаков заканчиваем проверку, так как число не превышает максимального значения типа Integer, а корректность ввода мы уже проверили}
else                                           {если число больше то проверяем его
                                                          дальше}
begin
if (length(w)>5) and (w[1]<> '-') then         {если длина числа больше пяти
                                                          знаков, и при этом первый знак, не знак
                                                          минуса то выводим сообщение о
                                                          превышении максимального
                                                          значения типа Integer}
begin
Write(rus('Вы ввели не число или число превышающее диапазон '));
WriteLn(rus('типа Integer (-32768..32767) '));
WriteLn('');
WriteLn(rus('Введите другое число'));
Proverka(w);                            {выполняем рекурсивный вход в
                                                          процедуру}
end;
if (w[1]= '-') and (length(w)>4) and (w>'-32768') then   {если первый знак числа, знак минуса, а число по длине меньше или равно четырем знакам или число больше чем четыре знака и в ходе сравнения строка со значением введенного числа, меньше или равна строке по значению с максимальным пределом типа Integer, то идем дальше. Иначе, выводим сообщение о превышении максимального значения типа Integer}
begin
Write(rus('Вы ввели не число или число превышающее диапазон '));
WriteLn(rus('типа Integer (-32768..32767) '));
WriteLn('');
WriteLn(rus('Введите другое число'));
Proverka(w);                            {выполняем рекурсивный вход в
                                                          процедуру}
end;
if (length(w)>4) and (w>'32767') then        {если число по длине меньше или равно четырем знакам или число больше чем четыре знака и в ходе сравнения строка со значением введенного числа, меньше или равна строке по значению с максимальным пределом типа Integer, то идем дальше. Иначе выводим сообщение о превышении максимального значения типа Integer}
begin
Write(rus('Вы ввели не число или число превышающее диапазон '));
WriteLn(rus('типа Integer (-32768..32767) '));
WriteLn('');
WriteLn(rus('Введите другое число'));
Proverka(w);                            {выполняем рекурсивный вход в
                                                          процедуру}
end;
end;
End;
Procedure Gou(w: WE); forward;     //Опережающее описание процедуры
Procedure Create2(var sag: PE);       {Процедура ввода элементов в ЛОС с сортировкой по возрастанию}
Var                                          
q, qq, s: PE;                              //адресные переменные
a: TE;                                       //переменная для ввода данных
Begin
writeln(' ');
WriteLn(rus('Введите элементы в ЛОС: '));
WriteLn(rus('Ввод завершите 0'));
if st2<>1 then                           //если ЛОС еще не был создан
begin
New(sag);                                 //создаем указатель начала списка
q:=sag^.next;                            //запоминаем адрес первого элемента ЛОС
end;
If st = 1 then                                     {если пользователь выбрал вариант работы, с типом Integer}
                                                 //st = 1 – работа с типом данных, Integer
begin
Proverka(w);                            {вход в процедуру проверки корректности
                                                          ввода данных}
a:= StrToInt(w);                       {перевод числа из строкового типа данных в целочисленный}
end
else                                                    {если пользователь выбрал вариант работы, работа с типом String}
                                                 //st = 2 – работа с типом данных, String
ReadLn(stroka);                       //ввод данных типа String
if (q= nil) or (st2=1) then                  {если ЛОС был пустым или ЛОС уже создавался}
Begin
New(q);                                    {создаем адресную переменную для
                                                          первого элемента}
If st = 1 then                             {если пользователь выбрал вариант работы, работа с типом Integer}
                                                 //st = 1 – работа с типом данных, Integer
q^.inf:= a                                  {заносим в информационную часть, значение данных}
else
q^.inf2:= stroka;                       {заносим в информационную часть, значение данных}
q^.next:= sag^.next;                 {в адресную часть второго элемента
                                                          заносим адресную часть первого
                                                          элемента}
sag^.next:= q;                           {в адресную часть первого элемента заносим адрес созданного указателя}
If st = 1 then                             {если пользователь выбрал вариант работы, работа с типом Integer}
                                                 //st = 1 – работа с типом данных, Integer
begin
Proverka(w);                            {вход в процедуру проверки корректности ввода данных}
a:= StrToInt(w);                       {перевод числа из строкового типа данных в целочисленный}
end
else
ReadLn(stroka);                       //ввод данных типа String
End;
If st = 1 then                             {если пользователь выбрал вариант работы, работа с типом Integer}
                                                 //st = 1 – работа с типом данных, Integer
begin
While a<>0 do                          {запускаем цикл выполняющийся пока не будет введен ноль}
Begin
New(q);                                    {создаем адресную переменную для первого элемента}
q^.inf:= a;                                 {заносим в информационную часть, значение данных}
q^.next:= sag^.next;                 {в адресную часть второго элемента заносим адресную часть первого элемента}
sag^.next:= q;                           {в адресную часть первого элемента заносим адрес созданного указателя}
                                                          //---------сортировка
qq:= sag^.next;                         //запоминаем адрес первого элемента ЛОС
While qq<>Nil do                     {запускаем цикл выполняющийся пока не будет достигнут конец списка}

begin
s:= qq;                                      //запоминаем адрес первого элемента ЛОС
qq:= qq^.next;                          {запоминаем адрес следующего элемента
                                                          ЛОС}
if (qq<>nil) then                       {если адресная переменная не равна указателю конца списка}
begin
begin
if (qq^.inf<s^.inf) then                      {если информационная часть следующего элемента меньше чем предыдущего, тогда:}
begin
a:= qq^.inf;                               {запоминаем значение информационной части следующего элемента}
qq^.inf:=s^.inf;                         {в информационную часть следующего элемента запоминаем значение информационной части
                                                          предыдущего элемента}
s^.inf:= a;                                 {в информационную часть предыдущего элемента запоминаем значение следующего элемента}
end;
end;
end;
end;                                          //---------конец сортировки
Proverka(w);                            {вход в процедуру проверки корректности ввода данных}
a:= StrToInt(w);                       {перевод числа из строкового типа данных в целочисленный}
end;
end
else
begin
While stroka<>'0' do                {запускаем цикл выполняющийся пока не будет введен ноль}
Begin
New(q);                                    {создаем адресную переменную для первого элемента}
q^.inf2:= stroka;                       {заносим в информационную часть, значение данных}
q^.next:= sag^.next;                 {в адресную часть второго элемента
                                                          заносим адресную часть первого
                                                          элемента}
sag^.next:= q;                           {в адресную часть первого элемента заносим адрес созданного указателя}
                                                          //---------сортировка
qq:= sag^.next;                         //запоминаем адрес первого элемента ЛОС
While qq<>Nil do                     {запускаем цикл выполняющийся пока не будет достигнут конец списка}
begin
s:= qq;                                      //запоминаем адрес первого элемента ЛОС
qq:= qq^.next;                          {запоминаем адрес следующего элемента
                                                          ЛОС}
if (qq<>nil) then                       {если адрес переменной не равен указателю конца списка}
begin
begin
if (qq^.inf2<s^.inf2) then                  {если информационная часть следующего элемента меньше чем предыдущего, тогда:}
begin
a:= qq^.inf2;                             {запоминаем значение информационной части следующего элемента}
qq^.inf2:=s^.inf2;                     {в информационную часть следующего элемента запоминаем значение информационной части
                                                          предыдущего элемента}
s^.inf2:= a;                               {в информационную часть предыдущего элемента запоминаем значение следующего элемента}
end;
end;
end;
end;
                                                          //---------конец сортировки
ReadLn(stroka);                       //ввод данных типа String
end;
end;
WriteLn('');
WriteLn(rus('Ваш итоговый ЛОС:'));
print(sag);                                 //вывод ЛОС на экран
WriteLn(' ');
if st2=1 then                             //если ЛОС наполняется первый раз
Gou(w);                                    {процедура перемещения между
                                                          процедурами}
End;
Procedure Vopros ( w: WE);             {процедура вывода списка вариантов дальнейших вариантов работы в ЛОС}
Begin
WriteLn(rus('___________________________________________'));
WriteLn(rus('Что Вы хотите выполнить дальше?'));
WriteLn('');
WriteLn(rus('2 - Добавить элемент в начало списка'));
Write(rus('3 - Добавить элемент в середину списка, перед указанным ‘));
WriteLn(rus('значением'));
Write(rus('4 - Добавить элемент в середину списка, после указанного ‘));
WriteLn(rus('значения'));
WriteLn(rus('5 - Добавить элемент в конец списка'));
WriteLn(rus(''));
WriteLn(rus('6 - Удалить элемент в начале списка'));
Write(rus('7 - Удалить элемент ЛОС стоящий перед указанным ‘));
WriteLn(rus('значением списка'));
Write(rus('8 - Удалить элемент ЛОС стоящий после указанного “));
WriteLn(rus('значения списка'));
WriteLn(rus('9 - Удалить определенный элемент в списке'));
WriteLn(rus('10 - Удалить элемент в конце списка'));
WriteLn(rus('11 - Удалить первый и последний элементы ЛОС'));
WriteLn('');
WriteLn(rus('12 - Очистить ЛОС'));
WriteLn('');
WriteLn(rus('13 - Поиск элемента по его значению'));
WriteLn('');
WriteLn(rus('14 - Сортировка элементов'));
WriteLn('');
Write(rus('15 - Подсчитать количество идентичных по содержанию '));
WriteLn(rus('элементов с указанным'));
WriteLn('');
WriteLn(rus('0 - Выход'));
WriteLn('');
WriteLn(rus('___________________________________________'));
End;
Procedure Gou( w: WE);                   {процедура перемещения между
                                                          процедурами}
Begin
WriteLn(rus('Нажмите Ввод для продолжения'));
ReadLn(W);                              //ждем нажатия Enter
While w<>'' do                         {проверяем был ли просто нажат Enter или пользователь что-то ввел. цикл будет работать пока пользователь не нажмет просто Enter, без ввода данных}
begin
WriteLn('');
if w='' then                               {если был нажат Enter без ввода данных продолжаем работу процедуры}
else                                           {иначе выдаем сообщение}
WriteLn(rus('Будьте внимательны, нужно просто нажать на ввод!'));
ReadLn(W);                              //ждем нажатия Enter
end;
WriteLn('');
WriteLn('');
Vopros(w);                               {процедура вывода списка вариантов дальнейших вариантов работы в ЛОС}
WriteLn;
WriteLn('');
proverka(w);                            {вход в процедуру проверки корректности ввода данных}
oper:=strtoint(w);                     {перевод числа из строкового типа данных в целочисленный}
While oper=1 do                      {если ЛОС не пустой то выводим
                                                          сообщение}
Begin
Write(rus('Ваш ЛОС не пустой, для создания нового '));
Writeln(rus('удалите все элементы текущего.'));
Writeln(rus('Выберите вариант дальнейших действий.'));
proverka(w);                            {вход в процедуру проверки корректности ввода данных}
oper:= StrToInt(w);                  {перевод числа из строкового типа данных в целочисленный}
end;
end;
. . .
Procedure Delet11 (var sag: PE);      {процедура удаления первого и последнего, элементов в ЛОС}
var
k, kk, q, qq: PE;                       //адресные переменные
Begin
WriteLn(rus('Ваш ЛОС выглядел так:'));
WriteLn('');
print(sag);                                 //процедура вывода ЛОС
WriteLn('');
q:= sag^.next;                           //запоминаем адрес первого элемента
k:= sag^.next;                           //запоминаем адрес первого элемента
If q^.next=Nil then                   {если адрес второго элемента содержит указывает на конец списка}
Begin
sag^.next:=q^.next;                  {в адресную часть первого элемента заносим указатель на конец списка}
dispose(k);                                //удаляем адрес первого элемента
WriteLn(rus('В ЛОС был только один элемент!'));      //выводим сообщение
WriteLn(' ');
End
Else                                          //иначе
Begin
qq:=sag^.next;                          //запоминаем адрес первого элемента
q:=qq^.next;                             //запоминаем адрес второго элемента
if (q^.next= Nil) then                {если адресная часть второго элемента указывает на конец списка (это означает что в ЛОС только два элемента)}
Begin
sag^.next:=Nil;                         {в адресную часть начала ЛОС заносим указатель на конец списка}                                   
dispose(q);                                //удаляем адрес первого элемента
dispose(q);                                //удаляем адрес второго элемента
End
Else                                          //иначе
Begin
q:= sag^.next;                           //запоминаем адрес второго элемента
sag^.next:=q^.next;                  {в адресную часть первого элемента заносим адрес второго элемента}
dispose(k);                                //удаляем адрес первого элемента
q:= sag^.next;                           //запоминаем адрес первого элемента
qq:=q^.next;                             //запоминаем адрес второго элемента
While (q<>Nil)do                     {цикл удаления последнего элемента
                                                          проходим по списку, до тех пор, пока указатель не будет равен значению, указателя на конец списка}
Begin
kk:=q;                                       //запоминаем адрес текущего элемента
q:=q^.next;                               //запоминание следующего адреса
k:= qq;                                      //запоминаем адрес следующего элемента
qq:=qq^.next;                           //запоминание следующего адреса
if qq=Nil then                           {если адресная часть следующего элемента указывает на значение конца списка значит мы нашли адрес последнего элемента ЛОС}
Begin
kk^.next:= qq;                          {заносим в адресную часть предыдущего элемента значение конца списка}
q:=kk^.next;                             {запоминание в переменную указателя, значение конца списка для выхода из цикла}
dispose(k);                                //удаляем адрес последнего элемента
End;
end;
End;
End;
q:=sag^.next;                            //запоминаем адрес начального элемента
if q= Nil then                            {если адрес начального элемента указывает на конец списка выводим сообщение}
Begin
WriteLn(rus('Ваш итоговый ЛОС:'));
WriteLn('');
print(sag);                                 //процедура вывода ЛОС на экран
WriteLn('');
proverka(w);                            {вход в процедуру проверки корректности ввода данных}
oper:= StrToInt(w);                  {перевод числа из строкового типа данных в целочисленный}
if oper = 0 then                         //если переменная равна нулю
exit;                                          //завершаем работу программы
While (oper <> 1) do                {цикл работает пока переменная не равна
                                                          единице}
Begin                                        {выводит сообщение, о не верно выбранной операции}
WriteLn('');
WriteLn(rus('Выбрана не та операция!'));
WriteLn(rus('_____________________________________'));
WriteLn('');
WriteLn(rus('Введите номер требуемой операции '));
WriteLn('');
proverka(w);                            {вход в процедуру проверки корректности ввода данных}
oper:= StrToInt(w);                  {перевод числа из строкового типа данных в целочисленный}
if oper = 0 then                         //если переменная равна нулю
exit;                                          //завершаем работу программы
end;
end
Else
Begin
Write(rus('После удаления первого и последнего элементов Ваш ЛОС’));
Writeln(rus(‘ выглядит так:'));
WriteLn('');
print(sag);                                 //процедура вывода ЛОС на экран
WriteLn('');
Gou(w);                                    {процедура перемещения между
                                                          процедурами}
End;
End;
. . .
Begin                                        //Выполнение самой программы
WriteLn(rus('Лабораторная работа студента группы ВСМ 6 05'));
WriteLn(rus('Антонова А.Е.'));
WriteLn(rus('Номер лабораторной # 1.18'));
WriteLn('');
WriteLn(rus('Для более удобной работы в программе'));
WriteLn(rus('разверните окно программы на максимальный размер'));
WriteLn('');
WriteLn(rus('Нажмите Ввод для продолжения'));
ReadLn(W);                              //ждем нажатия Enter
While w<>'' do                         {проверяем был ли просто нажат Enter или пользователь что-то ввел. цикл будет работать пока пользователь не нажмет просто Enter, без ввода данных}
begin
WriteLn('');
if w='' then                               {если был нажат Enter без ввода данных продолжаем работу процедуры}
else                                           {иначе выдаем сообщение}
WriteLn(rus('Будьте внимательны, нужно просто нажать на ввод!'));
ReadLn(W);                              //ждем нажатия Enter
end;
WriteLn(' ');
WriteLn(rus('В данной лабораторной, присутствуют следующие'));
WriteLn(rus('возможности работы с ЛОС:'));
WriteLn(rus('___________________________________________'));
WriteLn('');
WriteLn(rus('1 - Создать ЛОС'));
WriteLn('');
WriteLn(rus('2 - Добавить элемент в начало списка'));
Write(rus('3 - Добавить элемент в середину списка, перед указанным’));
WriteLn(rus(‘ значением'));
Write(rus('4 - Добавить элемент в середину списка, после указанного’));
WriteLn(rus(‘ значениея'));
WriteLn(rus('5 - Добавить элемент в конец списка'));
WriteLn(rus(''));
WriteLn(rus('6 - Удалить элемент в начале списка'));
Write(rus('7 - Удалить элемент ЛОС стоящий перед указанным ’));
WriteLn(rus(‘значением списка'));
Write(rus('8 - Удалить элемент ЛОС стоящий после указанного ’));
WriteLn(rus(‘значением списка'));
WriteLn(rus('9 - Удалить определенный элемент в списке'));
WriteLn(rus('10 - Удалить элемент в конце списка'));
WriteLn(rus('11 - Удалить первый и последний элементы ЛОС'));
WriteLn('');
WriteLn(rus('12 - Очистить ЛОС'));
WriteLn('');
WriteLn(rus('13 - Поиск элемента по его значению'));
WriteLn('');
WriteLn(rus('14 - Сортировка элементов'));
WriteLn('');
Write(rus('15 - Подсчитать количество идентичных по содержанию’));
WriteLn(rus(‘элементов'));
WriteLn(rus(' с указанным'));
WriteLn('');
WriteLn(rus('0 - Выход'));
WriteLn('');
WriteLn(rus('___________________________________________'));
WriteLn('');
Write(rus('Вы будете работать с числами (Тип Integer) - 1 '));
WriteLn(rus('или со строками (Тип String) - 2'));
While (st <> 1) and (st <> 2) do       {цикл проверки ввода номера варианта
                                                          работы}
Begin
WriteLn(' ');
WriteLn(rus('Выберите номер нужного варианта работы'));
WriteLn(' ');
ReadLn(w);
if (w <> '1') and (w <> '2') then        //если выбран не тот вариант работы
begin                                         //выводим сообщение
WriteLn(' ');
WriteLn(rus('Не правильно выбран номер варианта работы'));
end
else
st:= StrToInt(w);                      {перевод числа из строкового типа данных в целочисленный}
end;
WriteLn(' ');
Create2(sag);                            //процедура создания ЛОС
st2:=1;
WriteLn('');
WriteLn(rus('Нажмите Ввод для продолжения'));
ReadLn(W);                              //ждем нажатия Enter
While w<>'' do                         {проверяем был ли просто нажат Enter или пользователь что-то ввел. цикл будет работать пока пользователь не нажмет просто Enter, без ввода данных}
begin
WriteLn('');
if w='' then                               {если был нажат Enter без ввода данных продолжаем работу процедуры}
else                                           //иначе выдаем сообщение
WriteLn(rus('Будьте внимательны, нужно просто нажать на ввод!'));
ReadLn(W);                              //ждем нажатия Enter
end;
WriteLn('');
WriteLn('');
Vopros(w);                               {процедура вывода списка вариантов дальнейших вариантов работы в ЛОС}
WriteLn;
Begin                                        {Определение какая операция должна
                                                          быть запущена}
proverka(w);                            {вход в процедуру проверки корректности ввода данных}
oper:= StrToInt(w);                  {перевод числа из строкового типа данных в целочисленный}
if oper=1 then                           {если была выбрана первая операция, а ЛОС не пуст, выводим сообщение}
Begin
Write(rus('Ваш ЛОС не пустой, для создания нового '));
Writeln(rus('удалите все элементы текущего.'));
Writeln(rus('Выберите вариант дальнейших действий.'));
proverka(w);                            {вход в процедуру проверки корректности ввода данных}
oper:= StrToInt(w);                  {перевод числа из строкового типа данных в целочисленный}
end;
while oper<>0 do                     {цикл работает пока не выбрана операция выхода из программы}
begin
if (oper>=1) and (oper<=15) then     {проверка проходит между пятнадцатью
                                                          операциями}
begin
if oper= 1 then
begin
WriteLn;
WriteLn('');
Write(rus('Вы будете работать с числами (Тип Integer) - 1 '));
WriteLn(rus('или со строками (Тип String) - 2'));
st:=0;
While (st <> 1) and (st <> 2) do       {цикл проверки ввода номера варианта
                                                          работы}
Begin                                        //выводим сообщение
WriteLn(' ');
WriteLn(rus('Выберите номер нужного варианта работы'));
WriteLn(' ');
ReadLn(w);
if (w <> '1') and (w <> '2') then        //если выбран не тот вариант работы
begin
WriteLn(' ');
WriteLn(rus('Не правильно выбран номер варианта работы'));
end
else
st:= StrToInt(w);                      {перевод числа из строкового типа данных в целочисленный}
end;
Create2(sag);                            //процедура создания ЛОС
WriteLn;
end;
 . .
if oper= 11 then
begin
WriteLn;
Delet11(sag);
WriteLn;
end;
. . .
else
Begin
Writeln(rus('Не корректный ввод варианта операции '));
Writeln(rus('Попробуйте еще раз'));
proverka(w);                            {вход в процедуру проверки корректности ввода данных}
oper:= StrToInt(w);                  {перевод числа из строкового типа данных в целочисленный}
While oper=1 do                      {если ЛОС не пустой то выводим
                                                          сообщение}
Begin
Write(rus('Ваш ЛОС не пустой, для создания нового '));
Writeln(rus('удалите все элементы текущего.'));
Writeln(rus('Выберите вариант дальнейших действий.'));
proverka(w);                            {вход в процедуру проверки корректности ввода данных}
oper:= StrToInt(w);                  {перевод числа из строкового типа данных в целочисленный}
end;
end;
end;
if oper= 0 then                          //если переменная равна нулю, то
begin
exit;                                          //выход из программы
end;
end;
end. //Конец программы
ОПИСАНИЕ ТЕСТ-ПРИМЕРОВ
В контрольном прогоне программы используются следующие тест-примеры:
1.                 при просьбе нажать ввод, будет введена единица
2.                 при вопросе, с какими данными Вы будете работать, вместо 1 или 2, будет введена тройка
3.                 при вводе данных будет нажат Enter без ввода значения
4.                 при работе с данными типа Integer, при вводе значений будет введена не цифра, а буква
5.                 при работе с данными типа Integer, при вводе значений будет введено число, превышающее максимальное значение типа Integer
6.                 при выборе варианта продолжения работы программы, вместо нужного варианта будет введена буква или номер варианта, превышающий их количество
7.                 будет введен один элемент
8.                 будет введено два элемента
9.                 будет введено пять значений элементов ЛОС для проверки корректности работы программы
10.           после удаления и выводе вариантов продолжения работы с программой будет введен, номер, превышающий по значению предложенные варианты
РЕЗУЛЬТАТЫ КОНТРОЛЬНОГО ПРОГОНА
Тест-пример №1
При просьбе нажать ввод, вводиться единица. В ответ выводиться сообщение «Будьте внимательны, нужно просто нажать на ввод».
При вопросе, с какими данными Вы будете работать, вместо ввода варианта работы 1 или 2 вводиться вариант три, которого не существует. В ответ выводиться сообщение «Не правильно выбран вариант работы», дальше предлагается выбрать номер нужного варианта из предъявленных.
При вводе данных, не введя значение, нажимается ввод. В ответ выводиться сообщение «Вы не ввели данные или они не корректны, попробуйте еще раз».
При работе с ранее выбранным типом данных Integer, вводиться не число, а буква. После отработки процедуры проверки на корректность вводимых данных, выводиться сообщение «Вы ввели не корректные данные» и будет предложено повторить ввод данных еще раз.
При работе с данными типа Integer, вводится значений превышающее максимальное значение типа Integer. В ответ выводиться сообщение
«Вы ввели не число или число превышающее диапазон типа Integer
(-32768..32767)» и будет предложено ввести другое число.
а)                 На экран выводиться список вариантов продолжения работы с программой. Вместо номера варианта вводиться номер превышающий их количество. В ответ выводиться сообщение «Не корректный ввод варианта операции» и будет предложено ввести номер варианта задачи, еще раз.
б)                На экран выводиться список вариантов продолжения работы с программой. Вместо номера варианта вводиться буква. В ответ выводиться сообщение «Вы ввели не корректный данные» и будет предложено попробовать еще раз.
В ЛОС вводится только один элемент. Далее, выбирается операция по удалению первого и последнего элементов ЛОС. Так, как в ЛОС был только один элемент, выводиться сообщение «В ЛОС был только один элемент!». Далее, запускается процедура вывода на экран содержимого ЛОС. Но! Так, как ЛОС пустой, потому, что мы удалили этот, один элемент, который был в нем. Выводится сообщение «ЛОС пустой, выводить нечего!». Далее, выводиться сообщение с вопросом о ходе дальнейшей работы программы и выводятся варианты работ. С предложением ввести вариант и продолжить. Варианты:
1 – Создать (наполнить ЛОС)
0 – Выйти из программы
В ЛОС вводятся два элемента. Далее, выбирается операция по удалению первого и последнего элементов ЛОС. В ЛОС записаны два элемента, первый и последний. Значит они просто удаляются, а далее, запускается процедура вывода на экран содержимого ЛОС. Но! Так, как ЛОС пустой, потому, что мы удалили эти два элемента, которые были в нем. Выводится сообщение «ЛОС пустой, выводить нечего!». Далее, выводиться сообщение с вопросом о ходе дальнейшей работы программы и выводятся варианты работ, с предложением ввести вариант и продолжить. Варианты:
1 – Создать (наполнить ЛОС)
0 – Выйти из программы
Будет введено пять значений элементов ЛОС (1, 2, 3, 4, 5), для проверки корректности работы программы. В результате удаления первого и последнего элементов. ЛОС будет выглядеть так: (2, 3, 4).
Тест-пример №10
После удаления и выводе вариантов продолжения работы с программой будет введен, номер, превышающий по значению предложенные варианты. В итоге будет выведено сообщение «Выбрана не та операция!» и будет предложено ввести номер требуемой операции еще раз.

Вывод:
Из результатов тест-примеров можно сказать, что программа функционирует правильно и готова к эксплуатации.

Список использованных информационных источников:
1.     В.П. Сыромятников, «Структуры и алгоритмы обработки данных», лекции МИРЭА, 2007 уч. год
2.     В.В. Фаронов, «TURBO PASCAL 7.0» Начальный курс учебное пособие. –М.: «КНОРУС» 2006г. – 576 с
3.     А.Я. Архангельский, «Программирование в Delphi 6». –М.: ЗАО «Издательство БИНОМ» 2002г. – 1120 с.
4.     А.Я. Архангельский, Delphi 6 «Справочное пособие». –М.: ЗАО «Издательство БИНОМ» 2001г. – 1124 с.