суббота, 3 декабря 2011 г.

ТТП, Лекция 13

Лекция 13. Динамические структуры данных

Статические и динамические переменные

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

Указатель – переменная, которая содержит адрес другой переменной.

Имя:^Тип;

P1:^integer;
P2:^real;

Выделение и освобождение памяти

New(Указатель) –создает переменную и ее адрес записывает в переменную-указатель.
Dispose(Указатель) –  освобождает память, занимаемую динамической переменной.

Var
            P1,p2,p3:^integer;
Begin
            New(p1);
            New(p2);
            Readln(p1^,p2^);
            P3^:=p1^+p2^;
            Writeln(p3^);
            Dispose(p1);
End.

Список

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

type
     p_student=^student;
     student=record
          name:string[20];
          next:p_student;
     end;
var
     head:p_student; { начало списка }
     curr:p_student; { текущий элемент списка }
     buf:string[20]; { буфер для ввода с клавиатуры }
begin
     repeat
          write('Фамилия-> ');
          readln(buf);
          if length(buf)<>0 then
               begin
                    new(curr);
                    curr^.name:=buf;
                    curr^.next:=head;
                    head:=curr;
               end;
     until length(buf)=0;
     writeln('** Введенный список **');
     curr:=head;
     while curr<>NIL do begin
          writeln(curr^.name );
          curr:=curr^.next;
     end;
     readln;
end.

Контрольные вопросы
1. Что является значением переменной-указателя (в общем случае)?
2. Как выделить память для динамической переменной?
3. Как получить доступ к динамической переменной?
4. Что представляют из себя элементы динамической структуры «список»?
5. Из каких частей состоит запись, являющаяся элементом динамической структуры список?

ТТП, Лекция 12

Лекция 12. Модуль программиста

Структура модуля


unit ИмяМодуля;
interface
            { объявление типов, констант, переменных, процедур и функций,
   которые могут использоваться в программах, использующих этот модуль }
implementation
            { объявление типов, констант, переменных, процедур и функций,
              которые используются в процедурах и функциях модуля }

            { инструкции реализации процедур и функций модуля }
begin
            { инструкции инициализации переменных модуля }
end.

Пример модуля программиста


{ функции для решения задач комбинаторики }
unit Komb;

interface
    { k - кол-во элементов множества }
    { r - кол-во элементов подмножества }
    function sochet(k: integer; r: integer): longint;
    function razm  (k: integer; r: integer): longint;
    function perest(k: integer): longint;

implementation

    function factor(x: integer):longint;
       var
          f,i: longint;
       begin
          f:=1;
          for i:=2 to x do f:=f*i;
          factor:=f;
       end;

    function sochet(k: integer; r: integer): longint;
       begin
           sochet:=Round(factor(k)/(factor(r)*factor(k-r)));
       end;

   function razm(k: integer; r: integer): longint;
       begin
           razm:=Round(factor(k)/factor(k-r));
       end;

  function perest(k: integer): longint;
       begin
           perest:=factor(k);
       end;

  begin

  end.

Компиляция модуля 
Компилируется модуль обычным образом (не забыть задать режим компиляции «на диск»).

Пример использования модуля
uses komb; { используется модуль программиста "Комбинаторика" }
var
   k: integer;        { кол-во элементов множества }
   r: integer;        { кол-во элементов подмножества }
   p,a,c: longint;    { количество перестановок, размещений и сочетаний }

begin
     writeln('Введите кол-во элементов множества и подмножества');
     readln(k,r);
               p:=perest(k);
               a:=razm(k,r);
               c:=sochet(k,r);
               writeln('Количество перестановок ',k,' элементов равно ',p);
               writeln('Количество размещений из ',k,' по ',r,' равно ',a);
               writeln('Количество различных сочетаний из ',k,' по ',r,' равно ',c);
     writeln('Для завершения работы программы нажмите <Enter>');
     readln;
end.


Контрольные вопросы
1. Перечислите разделы модуля программиста
2. Для чего указывается объявление процедуры (функции) в разделе interface?
3. Как выполнить компиляцию модуля?
4. Что является результатом компиляции модуля?
5. Что надо сделать, чтобы функции и процедуры, находящиеся в модуле, стали доступны программе, которой они нужны?

вторник, 15 ноября 2011 г.

ТТП, Лекция 11

Лекция 11. Повторное использование кода. Подпрограммы


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

program p;

   { подпрограмма  (процедура) }
   procedure MyProc( параметры);
      var

      begin

     end;

   { основная программа}
   begin
  
         MyProc( …); { инструкция вызова подпрограммы-процедуры}
 
    end;


Переменные, объявленные внутри подпрограммы, называются локальными.

Функция программиста

Объявление

Function Функция(СпиокПараметров):Тип;
var
            { локальные переменные }
begin

end;

Использование функции


Переменная := Функция(СписокПараметров)

Формальные и фактические параметры

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

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

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

Пример функции программиста
{ Вычисление количества сочетаний из k по r
  с использованием функции программиста }

{ функция программиста}
function Factor(x: integer):longint;
var
   f: integer; { факториал числа x }
   i: integer; { счетчик циклов }
begin
    f:=1;
    for i:=2 to x do
        f:=f*i;
    factor:=f;
end;

{ основная программа }
var
   k: integer; { кол-во элементов множества }
   r: integer; { кол-во элементов подмножества }
   c: real;    { количество сочетаний }
begin
     write('Введите количество элементов');
     write('множества и подмножества -> ');
     readln(k,r);

     if r <= k then
        begin
           c:=Factor(k)/(Factor(r)*Factor(k-r));
           write('Количество сочетаний из ');
           writeln(k,' по ',r,' равно ',c:4:0);
         end
        else
           writeln('Ошибка исходных данных.');

     writeln('Для завершения нажмите <Enter>');
     readln;
end.


ТТП, Лекция 10

Лекция 10. Типы данных программиста

Тип данных программиста объявляется в разделе type

Перечисление

Тип=(значение_1,значение_2, ….значение_К)
type
TDayOfWeek =(PN,VT,SR,CT,PT,SB,VS)
var
            ThisDay: TDayOfWeek;

begin
            if (ThisDay = SB) or (ThtisDay = VS)
                then


Замечание: Перечисление – это, фактически, объявление именованных констант.
Const
PN =0;
VT =1;
SR = 2;
CT = 3;
PT = 4;
SB = 5;
VS = 6;

Интервальный тип

Типа  = НижняяГраница . . ВерхняяГраница;

Пример 1.
type
TDiapazon = 1 .. 10;
var
            Tabl: array [TDiapazon] of integer;

Пример 2.
const
     HBound = 100;
type
     TIndex = 1 .. HBound;
var
     a: array[TIndax] of integer;

Запись


type
Тип = record
                        Поле_1 : Тип_1;

                        Поле_К : Тип_К;
end;

type
            TBook  = record
                        title: string[45];
                        author:string[25];
                        price: real;
            End;

var

          books: array[1..25] of TBook;
          i: integer;
begin
         { вывод массива записей }
         for i:=1 to 25 do
            begin
                        write(bools[i].author);           
                        write(bools[i].cena);  
                        writln(bools[i].price:6:2);      
            end     
end;

среда, 9 ноября 2011 г.

ТТП, Лекция 9

Лекция 9. Поиск в массиве

Методы поиска:
  • перебором – в неупорядоченном массиве;
  • половинного деления – в упорядоченном массиве.

Метод перебора

{ поиск в массиве методом перебора }
const
     SIZE=10;
var
     m:array[1..SIZE] of integer; { массив целых}
     obr:integer;               { образец для поиска }
     found:boolean;             { признак совпадения с образцом }
     i:integer;
begin
     { ввод массива }

     { здесь массив введен }
     write('Введите образец для поиска (целое число)-> ');
     readln(obr);

     found:=FALSE; { пусть искомого числа в массиве нет }
     i:=1;         { проверяем с первого элемента массива }
     repeat
          if m[i] = obr
               then found:=TRUE   { нужный элемент найден }
               else i:=i+1;       { переход к следующему элементу }

     until (i>SIZE) or (found); { завершим, если совпадение
                                { с образцом или проверен }
                                { последний элемент массива }
     if found then
         
 writeln('Совпадение с элементом номер', i:3,'. ',
                   'Поиск успешен.')
        else
         
 writeln('Числа ',
obr, 'в массиве нет');
end.

Метод половинного деления

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

{ Бинарный поиск в массиве }
const
     SIZE=9;
var
     a:array[1..9] of integer; { массив целых }
     obr:integer;              { искомое число }
     sred,verh,niz:integer;    { номера среднего, верхнего и нижнего}
                               { эл-тов массива}
     found:boolean;            { признак совпадения с образцом }
     n:integer;                { счетчик сравнений с образцом }
     i:integer;
begin
     { ввод массива }

     { Здесь массив введен }
     write('Введите образец для поиска (целое число) -> ');
     readln(obr);
     verh:=1;
     niz:=SIZE;
     found:=FALSE; { пусть искомого числа в массиве нет }
     n:=0;
     repeat
          sred:=(niz-verh) div 2 +verh;
          n:=n+1;
          if a[sred] = obr then
               found:=TRUE
            else
               begin
                  if obr < a[sred]
                    then niz:=sred-1
                    else verh:=sred+1;
               end;
     until (verh > niz) or found;
     if found
          then write('Совпадение с элементом номер ',
                      sred,'. Выполнено ',n,' сравнений.')
          else writeln('Числа ',obr,'в массиве нет.');
     writeln('Для завершения работы программы нажмите <Enrer>');
     readln;
end.

ТТП, Лекция 8

Лекция 8. Сортировка массива

Сортировка – процесс перестановки элементов массива с целью их упорядочивания по возрастанию или убыванию.
Например, после сортировки массива а по возрастанию должно выполняться условие:
A[1]≤a[2]≤   ≤a[SIZE]

Сортировка массива методом прямого выбора

const
     SIZE=5;
var
     a:array[1..SIZE] of integer;
     i:integer;   { номер элемента, от которого ведется поиск }
     min:integer; { номер минимального элемента в части }
                  { массива от i до верхней границы массива }
     j:integer;   { номер эл-та, сравниваемого с минимальным }
     buf:integer; { буфер, используется для обмена эл-тов массива }
     k:integer;
begin
     writeln('Сортировка массива.');
     write('Введите',SIZE:3,' целых в одной строке ');
     writeln('через пробел и нажмите <Enter>');
     for k:=1 to SIZE-1 do read(a[k]);
     readln(a[SIZE]);

     writeln('Сортировка');
     for i:=1 to SIZE-1 do
        begin
          { поиск минимального эл-та
          в части массива от a[i] до a[SIZE]}
          min:=i;
          for j:=i+1 to SIZE do
               if a[j]<a[min] then min:=j;
          buf:=a[i];
          a[i]:=a[min];
          a[min]:=buf;

          { отладочная печать: вывод массива }
          for k:=1 to SIZE do write(a[k],' ');
          writeln;
     end;
     writeln('Массив отсортирован.');
end.

Сортировка массива метод пузырька

{ сортировка массива целых методом пузырька }
const
     SIZE=5;
var
     a:array[1..SIZE] of integer;
     i:integer; { счетчик циклов }
     k:integer; { индекс элемента массива }
     buf:integer;
begin
     writeln('Сортировка массива');

     write('Введите в одной строке',SIZE:3,' целых чисел и нажмите <Enter>');
     for k:=1 to SIZE-1 do
             read(a[k]);
     readln(a[SIZE]);

     writeln('Сортировка');
     for i:=1 to SIZE-1 do
        begin
          for k:=1 to SIZE-1 do
             begin
               if a[k]>a[k+1] then
                   begin
                      { обменяем k-й и (k+1)-й элементы }
                      buf:=a[k];
                      a[k]:=a[k+1];
                      a[k+1]:=buf;
                  end;
             end;
         
          { цикл сортировки выполнен }
          for k:=1 to SIZE do
               write(a[k],' ');
          writeln;
     end;
    
     writeln('Массив отсортирован');
end.